eu07/maszyna
1
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-03-22 15:05:03 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
91470458b44fd258555a580e7ced36d8ea12b2d8
maszyna/DynObj.cpp
ShaXbee 45f4c0d98a Set dp branch as trunk
2015-04-03 13:34:06 +00:00

4359 lines
184 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------
/*
MaSzyna EU07 locomotive simulator
Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others
*/
#include "system.hpp"
#include "classes.hpp"
#pragma hdrstop
#include "DynObj.h"
#include "Timer.h"
#include "Usefull.h"
//McZapkie-260202
#include "Globals.h"
#include "Texture.h"
#include "AirCoupler.h"
#include "TractionPower.h"
#include "Ground.h" //bo Global::pGround->bDynamicRemove
#include "Event.h"
#include "Driver.h"
#include "Camera.h" //bo likwidujemy trzęsienie
#include "Console.h"
#include "Traction.h"
#pragma package(smart_init)
//Ra: taki zapis funkcjonuje lepiej, ale może nie jest optymalny
#define vWorldFront vector3(0,0,1)
#define vWorldUp vector3(0,1,0)
#define vWorldLeft CrossProduct(vWorldUp,vWorldFront)
//Ra: bo te poniżej to się powielały w każdym module odobno
//vector3 vWorldFront=vector3(0,0,1);
//vector3 vWorldUp=vector3(0,1,0);
//vector3 vWorldLeft=CrossProduct(vWorldUp,vWorldFront);
#define M_2PI 6.283185307179586476925286766559;
const float maxrot=(M_PI/3.0); //60°
//---------------------------------------------------------------------------
void __fastcall TAnimPant::AKP_4E()
{//ustawienie wymiarów dla pantografu AKP-4E
vPos=vector3(0,0,0); //przypisanie domyśnych współczynników do pantografów
fLenL1=1.22; //1.176289 w modelach
fLenU1=1.755; //1.724482197 w modelach
fHoriz=0.535; //0.54555075 przesunięcie ślizgu w długości pojazdu względem osi obrotu dolnego ramienia
fHeight=0.07; //wysokość ślizgu ponad oś obrotu
fWidth=0.635; //połowa szerokości ślizgu, 0.635 dla AKP-1 i AKP-4E
fAngleL0=DegToRad(2.8547285515689267247882521833308);
fAngleL=fAngleL0; //początkowy kąt dolnego ramienia
//fAngleU0=acos((1.22*cos(fAngleL)+0.535)/1.755); //górne ramię
fAngleU0=acos((fLenL1*cos(fAngleL)+fHoriz)/fLenU1); //górne ramię
fAngleU=fAngleU0; //początkowy kąt
//PantWys=1.22*sin(fAngleL)+1.755*sin(fAngleU); //wysokość początkowa
PantWys=fLenL1*sin(fAngleL)+fLenU1*sin(fAngleU)+fHeight; //wysokość początkowa
PantTraction=PantWys;
hvPowerWire=NULL;
fWidthExtra=0.381; //(2.032m-1.027)/2
//poza obszarem roboczym jest aproksymacja łamaną o 5 odcinkach
fHeightExtra[0]= 0.0; //+0.0762
fHeightExtra[1]=-0.01; //+0.1524
fHeightExtra[2]=-0.03; //+0.2286
fHeightExtra[3]=-0.07; //+0.3048
fHeightExtra[4]=-0.15; //+0.3810
};
//---------------------------------------------------------------------------
int __fastcall TAnim::TypeSet(int i,int fl)
{//ustawienie typu animacji i zależnej od niego ilości animowanych submodeli
fMaxDist=-1.0; //normalnie nie pokazywać
switch (i)
{//maska 0x000F: ile używa wskaźników na submodele (0 gdy jeden, wtedy bez tablicy)
//maska 0x00F0: 0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki
//maska 0xFF00: ile używa liczb float dla współczynników i stanu
case 0: iFlags=0x000; break; //0-oś
case 1: iFlags=0x010; break; //1-drzwi
case 2: iFlags=0x020;
fParam=fl?new float[fl]:NULL;
iFlags+=fl<<8;
break; //2-wahacz, dźwignia itp.
case 3: iFlags=0x030; break; //3-zderzak
case 4: iFlags=0x040; break; //4-wózek
case 5: //5-pantograf - 5 submodeli
iFlags=0x055;
fParamPants=new TAnimPant();
fParamPants->AKP_4E();
break;
case 6: iFlags=0x068; break; //6-tłok i rozrząd - 8 submodeli
default: iFlags=0;
}
yUpdate=NULL;
return iFlags&15; //ile wskaźników rezerwować dla danego typu animacji
};
__fastcall TAnim::TAnim()
{//potrzebne to w ogóle?
iFlags=-1; //nieznany typ - destruktor nic nie usuwa
};
__fastcall TAnim::~TAnim()
{//usuwanie animacji
switch (iFlags&0xF0)
{//usuwanie struktur, zależnie ile zostało stworzonych
case 0x20: //2-wahacz, dźwignia itp.
delete fParam;
break;
case 0x50: //5-pantograf
delete fParamPants;
break;
case 0x60: //6-tłok i rozrząd
break;
}
};
void __fastcall TAnim::Parovoz()
{//animowanie tłoka i rozrządu parowozu
};
//---------------------------------------------------------------------------
TDynamicObject* __fastcall TDynamicObject::FirstFind(int &coupler_nr)
{//szukanie skrajnego połączonego pojazdu w pociagu
//od strony sprzegu (coupler_nr) obiektu (start)
TDynamicObject* temp=this;
for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu
{
if (!temp)
return NULL; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów
if (temp->MoverParameters->Couplers[coupler_nr].CouplingFlag==0)
return temp; //nic nie ma już dalej podłączone
if (coupler_nr==0)
{//jeżeli szukamy od sprzęgu 0
if (temp->PrevConnected) //jeśli mamy coś z przodu
{
if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->PrevConnected; //ten jest od strony 0
}
else
return temp; //jeśli jednak z przodu nic nie ma
}
else
{
if (temp->NextConnected)
{if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->NextConnected; //ten pojazd jest od strony 1
}
else
return temp; //jeśli jednak z tyłu nic nie ma
}
}
return NULL; //to tylko po wyczerpaniu pętli
};
//---------------------------------------------------------------------------
float __fastcall TDynamicObject::GetEPP()
{//szukanie skrajnego połączonego pojazdu w pociagu
//od strony sprzegu (coupler_nr) obiektu (start)
TDynamicObject* temp=this;
int coupler_nr=0;
float eq=0,am=0;
for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu
{
if (!temp)
break; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów
eq+=temp->MoverParameters->PipePress*temp->MoverParameters->Dim.L;
am+=temp->MoverParameters->Dim.L;
if ((temp->MoverParameters->Couplers[coupler_nr].CouplingFlag&2)!=2)
break; //nic nie ma już dalej podłączone
if (coupler_nr==0)
{//jeżeli szukamy od sprzęgu 0
if (temp->PrevConnected) //jeśli mamy coś z przodu
{
if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->PrevConnected; //ten jest od strony 0
}
else
break; //jeśli jednak z przodu nic nie ma
}
else
{
if (temp->NextConnected)
{if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->NextConnected; //ten pojazd jest od strony 1
}
else
break; //jeśli jednak z tyłu nic nie ma
}
}
temp=this;
coupler_nr=1;
for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu
{
if (!temp)
break; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów
eq+=temp->MoverParameters->PipePress*temp->MoverParameters->Dim.L;
am+=temp->MoverParameters->Dim.L;
if ((temp->MoverParameters->Couplers[coupler_nr].CouplingFlag&2)!=2)
break; //nic nie ma już dalej podłączone
if (coupler_nr==0)
{//jeżeli szukamy od sprzęgu 0
if (temp->PrevConnected) //jeśli mamy coś z przodu
{
if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->PrevConnected; //ten jest od strony 0
}
else
break; //jeśli jednak z przodu nic nie ma
}
else
{
if (temp->NextConnected)
{if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
temp=temp->NextConnected; //ten pojazd jest od strony 1
}
else
break; //jeśli jednak z tyłu nic nie ma
}
}
eq-=MoverParameters->PipePress*MoverParameters->Dim.L;
am-=MoverParameters->Dim.L;
return eq/am;
};
//---------------------------------------------------------------------------
TDynamicObject* __fastcall TDynamicObject::GetFirstDynamic(int cpl_type)
{//Szukanie skrajnego połączonego pojazdu w pociagu
//od strony sprzegu (cpl_type) obiektu szukajacego
//Ra: wystarczy jedna funkcja do szukania w obu kierunkach
return FirstFind(cpl_type); //używa referencji
};
/*
TDynamicObject* __fastcall TDynamicObject::GetFirstCabDynamic(int cpl_type)
{//ZiomalCl: szukanie skrajnego obiektu z kabiną
TDynamicObject* temp=this;
int coupler_nr=cpl_type;
for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu
{
if (!temp)
return NULL; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów
if (temp->MoverParameters->CabNo!=0&&temp->MoverParameters->SandCapacity!=0)
return temp; //nic nie ma już dalej podłączone
if (temp->MoverParameters->Couplers[coupler_nr].CouplingFlag==0)
return NULL;
if (coupler_nr==0)
{//jeżeli szukamy od sprzęgu 0
if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
if (temp->PrevConnected)
temp=temp->PrevConnected; //ten jest od strony 0
}
else
{
if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony
coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu
if (temp->NextConnected)
temp=temp->NextConnected; //ten pojazd jest od strony 1
}
}
return NULL; //to tylko po wyczerpaniu pętli
};
*/
void TDynamicObject::ABuSetModelShake(vector3 mShake)
{
modelShake=mShake;
};
int __fastcall TDynamicObject::GetPneumatic(bool front, bool red)
{
int x,y,z; //1=prosty, 2=skośny
if (red)
{
if (front)
{
x=btCPneumatic1.GetStatus();
y=btCPneumatic1r.GetStatus();
}
else
{
x=btCPneumatic2.GetStatus();
y=btCPneumatic2r.GetStatus();
}
}
else
if (front)
{
x=btPneumatic1.GetStatus();
y=btPneumatic1r.GetStatus();
}
else
{
x=btPneumatic2.GetStatus();
y=btPneumatic2r.GetStatus();
}
z=0; //brak węży?
if ((x==1)&&(y==1)) z=3; //dwa proste
if ((x==2)&&(y==0)) z=1; //lewy skośny, brak prawego
if ((x==0)&&(y==2)) z=2; //brak lewego, prawy skośny
return z;
}
void __fastcall TDynamicObject::SetPneumatic(bool front,bool red)
{
int x=0,ten,tamten;
ten=GetPneumatic(front,red); //1=lewy skos,2=prawy skos,3=dwa proste
if (front)
if (PrevConnected) //pojazd od strony sprzęgu 0
tamten=PrevConnected->GetPneumatic((PrevConnectedNo==0?true:false),red);
if (!front)
if (NextConnected) //pojazd od strony sprzęgu 1
tamten=NextConnected->GetPneumatic((NextConnectedNo==0?true:false),red);
if (ten==tamten) //jeśli układ jest symetryczny
switch (ten)
{
case 1: x=2; break; //mamy lewy skos, dać lewe skosy
case 2: x=3; break; //mamy prawy skos, dać prawe skosy
case 3: //wszystkie cztery na prosto
if (MoverParameters->Couplers[front?0:1].Render) x=1; else x=4;
break;
}
else
{
if (ten==2) x=4;
if (ten==1) x=1;
if (ten==3) if (tamten==1) x=4; else x=1;
}
if (front)
{if (red) cp1=x; else sp1=x;} //który pokazywać z przodu
else
{if (red) cp2=x; else sp2=x;} //który pokazywać z tyłu
}
void TDynamicObject::UpdateAxle(TAnim *pAnim)
{//animacja osi
pAnim->smAnimated->SetRotate(float3(1,0,0),*pAnim->dWheelAngle);
};
void TDynamicObject::UpdateBoogie(TAnim *pAnim)
{//animacja wózka
pAnim->smAnimated->SetRotate(float3(1,0,0),*pAnim->dWheelAngle);
};
void TDynamicObject::UpdateDoorTranslate(TAnim *pAnim)
{//animacja drzwi - przesuw
//WriteLog("Dla drzwi nr:", i);
//WriteLog("Wspolczynnik", DoorSpeedFactor[i]);
//Ra: te współczynniki są bez sensu, bo modyfikują wektor przesunięcia
//w efekcie drzwi otwierane na zewnątrz będą odlatywac dowolnie daleko :)
//ograniczyłem zakres ruchu funkcją max
if (pAnim->smAnimated)
{
if (pAnim->iNumber&1)
pAnim->smAnimated->SetTranslate(vector3(0,0,Max0R(dDoorMoveR*pAnim->fSpeed,dDoorMoveR)));
else
pAnim->smAnimated->SetTranslate(vector3(0,0,Max0R(dDoorMoveL*pAnim->fSpeed,dDoorMoveL)));
}
};
void TDynamicObject::UpdateDoorRotate(TAnim *pAnim)
{//animacja drzwi - obrót
if (pAnim->smAnimated)
{//if (MoverParameters->DoorOpenMethod==2) //obrotowe albo dwójłomne (trzeba kombinowac submodelami i ShiftL=90,R=180)
if (pAnim->iNumber&1)
pAnim->smAnimated->SetRotate(float3(1,0,0),dDoorMoveR);
else
pAnim->smAnimated->SetRotate(float3(1,0,0),dDoorMoveL);
}
};
void TDynamicObject::UpdateDoorFold(TAnim *pAnim)
{//animacja drzwi - obrót
if (pAnim->smAnimated)
{//if (MoverParameters->DoorOpenMethod==2) //obrotowe albo dwójłomne (trzeba kombinowac submodelami i ShiftL=90,R=180)
if (pAnim->iNumber&1)
{pAnim->smAnimated->SetRotate(float3(0,0,1),dDoorMoveR);
TSubModel *sm=pAnim->smAnimated->ChildGet(); //skrzydło mniejsze
if (sm)
{sm->SetRotate(float3(0,0,1),-dDoorMoveR-dDoorMoveR); //skrzydło większe
sm=sm->ChildGet();
if (sm)
sm->SetRotate(float3(0,1,0),dDoorMoveR); //podnóżek?
}
}
else
{pAnim->smAnimated->SetRotate(float3(0,0,1),dDoorMoveL);
//SubModel->SetRotate(float3(0,1,0),fValue*360.0);
TSubModel *sm=pAnim->smAnimated->ChildGet(); //skrzydło mniejsze
if (sm)
{sm->SetRotate(float3(0,0,1),-dDoorMoveL-dDoorMoveL); //skrzydło większe
sm=sm->ChildGet();
if (sm)
sm->SetRotate(float3(0,1,0),dDoorMoveL); //podnóżek?
}
}
}
};
void TDynamicObject::UpdatePant(TAnim *pAnim)
{//animacja pantografu - 4 obracane ramiona, ślizg piąty
float a,b,c;
a=RadToDeg(pAnim->fParamPants->fAngleL-pAnim->fParamPants->fAngleL0);
b=RadToDeg(pAnim->fParamPants->fAngleU-pAnim->fParamPants->fAngleU0);
c=a+b;
if (pAnim->smElement[0]) pAnim->smElement[0]->SetRotate(float3(-1,0,0),a); //dolne ramię
if (pAnim->smElement[1]) pAnim->smElement[1]->SetRotate(float3(1,0,0),a);
if (pAnim->smElement[2]) pAnim->smElement[2]->SetRotate(float3(1,0,0),c); //górne ramię
if (pAnim->smElement[3]) pAnim->smElement[3]->SetRotate(float3(-1,0,0),c);
if (pAnim->smElement[4]) pAnim->smElement[4]->SetRotate(float3(-1,0,0),b); //ślizg
};
void TDynamicObject::UpdateLeverDouble(TAnim *pAnim)
{//animacja gałki zależna od double
pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->fDoubleBase);
};
void TDynamicObject::UpdateLeverFloat(TAnim *pAnim)
{//animacja gałki zależna od float
pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->fFloatBase);
};
void TDynamicObject::UpdateLeverInt(TAnim *pAnim)
{//animacja gałki zależna od int
pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->iIntBase);
};
void TDynamicObject::UpdateLeverEnum(TAnim *pAnim)
{//ustawienie kąta na wartość wskazaną przez int z tablicy fParam
//pAnim->fParam[0]; - dodać lepkość
pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fParam[*pAnim->iIntBase]);
};
//ABu 29.01.05 przeklejone z render i renderalpha: *********************
void __inline TDynamicObject::ABuLittleUpdate(double ObjSqrDist)
{//ABu290105: pozbierane i uporzadkowane powtarzajace sie rzeczy z Render i RenderAlpha
//dodatkowy warunek, if (ObjSqrDist<...) zeby niepotrzebnie nie zmianiec w obiektach,
//ktorych i tak nie widac
//NBMX wrzesien, MC listopad: zuniwersalnione
btnOn=false; //czy przywrócić stan domyślny po renderowaniu
if (mdLoad) //tymczasowo ładunek na poziom podłogi
if (vFloor.z>0.0)
mdLoad->GetSMRoot()->SetTranslate(modelShake+vFloor);
if (ObjSqrDist<160000) //gdy bliżej niż 400m
{
for (int i=0;i<iAnimations;++i) //wykonanie kolejnych animacji
if (ObjSqrDist<pAnimations[i].fMaxDist)
if (pAnimations[i].yUpdate) //jeśli zdefiniowana funkcja
pAnimations[i].yUpdate(pAnimations+i); //aktualizacja animacji (położenia submodeli
if (ObjSqrDist<2500) //gdy bliżej niż 50m
{
//ABu290105: rzucanie pudlem
//te animacje wymagają bananów w modelach!
mdModel->GetSMRoot()->SetTranslate(modelShake);
if (mdKabina)
mdKabina->GetSMRoot()->SetTranslate(modelShake);
if (mdLoad)
mdLoad->GetSMRoot()->SetTranslate(modelShake+vFloor);
if (mdLowPolyInt)
mdLowPolyInt->GetSMRoot()->SetTranslate(modelShake);
if (mdPrzedsionek)
mdPrzedsionek->GetSMRoot()->SetTranslate(modelShake);
//ABu: koniec rzucania
//ABu011104: liczenie obrotow wozkow
ABuBogies();
//Mczapkie-100402: rysowanie lub nie - sprzegow
//ABu-240105: Dodatkowy warunek: if (...).Render, zeby rysowal tylko jeden
//z polaczonych sprzegow
if ((TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_coupler))
&&(MoverParameters->Couplers[0].Render))
{btCoupler1.TurnOn(); btnOn=true;}
//else btCoupler1.TurnOff();
if ((TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_coupler))
&&(MoverParameters->Couplers[1].Render))
{btCoupler2.TurnOn(); btnOn=true;}
//else btCoupler2.TurnOff();
//********************************************************************************
//przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render' - juz nie
//przewody powietrzne, yB: decyzja na podstawie polaczen w t3d
if (Global::bnewAirCouplers)
{
SetPneumatic(false,false); //wczytywanie z t3d ulozenia wezykow
SetPneumatic(true,false); //i zapisywanie do zmiennej
SetPneumatic(true,true); //ktore z nich nalezy
SetPneumatic(false,true); //wyswietlic w tej klatce
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_pneumatic))
{
switch (cp1)
{
case 1: btCPneumatic1.TurnOn(); break;
case 2: btCPneumatic1.TurnxOn(); break;
case 3: btCPneumatic1r.TurnxOn(); break;
case 4: btCPneumatic1r.TurnOn(); break;
}
btnOn=true;
}
//else
//{
// btCPneumatic1.TurnOff();
// btCPneumatic1r.TurnOff();
//}
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_pneumatic))
{
switch (cp2)
{
case 1: btCPneumatic2.TurnOn(); break;
case 2: btCPneumatic2.TurnxOn(); break;
case 3: btCPneumatic2r.TurnxOn(); break;
case 4: btCPneumatic2r.TurnOn(); break;
}
btnOn=true;
}
//else
//{
// btCPneumatic2.TurnOff();
// btCPneumatic2r.TurnOff();
//}
//przewody zasilajace, j.w. (yB)
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_scndpneumatic))
{
switch (sp1)
{
case 1: btPneumatic1.TurnOn(); break;
case 2: btPneumatic1.TurnxOn(); break;
case 3: btPneumatic1r.TurnxOn(); break;
case 4: btPneumatic1r.TurnOn(); break;
}
btnOn=true;
}
//else
//{
// btPneumatic1.TurnOff();
// btPneumatic1r.TurnOff();
//}
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_scndpneumatic))
{
switch (sp2)
{
case 1: btPneumatic2.TurnOn(); break;
case 2: btPneumatic2.TurnxOn(); break;
case 3: btPneumatic2r.TurnxOn(); break;
case 4: btPneumatic2r.TurnOn(); break;
}
btnOn=true;
}
//else
//{
// btPneumatic2.TurnOff();
// btPneumatic2r.TurnOff();
//}
}
//*********************************************************************************/
else //po staremu ABu'oewmu
{
//przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render'
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_pneumatic))
{
if (MoverParameters->Couplers[0].Render)
btCPneumatic1.TurnOn();
else
btCPneumatic1r.TurnOn();
btnOn=true;
}
//else
//{
// btCPneumatic1.TurnOff();
// btCPneumatic1r.TurnOff();
//}
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_pneumatic))
{
if (MoverParameters->Couplers[1].Render)
btCPneumatic2.TurnOn();
else
btCPneumatic2r.TurnOn();
btnOn=true;
}
//else
//{
// btCPneumatic2.TurnOff();
// btCPneumatic2r.TurnOff();
//}
//przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render' //yB - zasilajace
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_scndpneumatic))
{
if (MoverParameters->Couplers[0].Render)
btPneumatic1.TurnOn();
else
btPneumatic1r.TurnOn();
btnOn=true;
}
//else
//{
// btPneumatic1.TurnOff();
// btPneumatic1r.TurnOff();
//}
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_scndpneumatic))
{
if (MoverParameters->Couplers[1].Render)
btPneumatic2.TurnOn();
else
btPneumatic2r.TurnOn();
btnOn=true;
}
//else
//{
// btPneumatic2.TurnOff();
// btPneumatic2r.TurnOff();
//}
}
//*************************************************************/// koniec wezykow
// uginanie zderzakow
for (int i=0; i<2; i++)
{
double dist=MoverParameters->Couplers[i].Dist/2.0;
if (smBuforLewy[i])
if (dist<0)
smBuforLewy[i]->SetTranslate(vector3(dist,0,0));
if (smBuforPrawy[i])
if (dist<0)
smBuforPrawy[i]->SetTranslate(vector3(dist,0,0));
}
}
//Winger 160204 - podnoszenie pantografow
//przewody sterowania ukrotnionego
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll))
{btCCtrl1.TurnOn(); btnOn=true;}
//else btCCtrl1.TurnOff();
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll))
{btCCtrl2.TurnOn(); btnOn=true;}
//else btCCtrl2.TurnOff();
//McZapkie-181103: mostki przejsciowe
if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_passenger))
{btCPass1.TurnOn(); btnOn=true;}
//else btCPass1.TurnOff();
if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_passenger))
{btCPass2.TurnOn(); btnOn=true;}
//else btCPass2.TurnOff();
if (MoverParameters->Battery)
{//sygnaly konca pociagu
if (btEndSignals1.Active())
{
if (TestFlag(iLights[0],2)
||TestFlag(iLights[0],32))
{btEndSignals1.TurnOn(); btnOn=true;}
//else btEndSignals1.TurnOff();
}
else
{
if (TestFlag(iLights[0],2))
{btEndSignals11.TurnOn(); btnOn=true;}
//else btEndSignals11.TurnOff();
if (TestFlag(iLights[0],32))
{btEndSignals13.TurnOn(); btnOn=true;}
//else btEndSignals13.TurnOff();
}
if (btEndSignals2.Active())
{
if (TestFlag(iLights[1],2)
||TestFlag(iLights[1],32))
{btEndSignals2.TurnOn(); btnOn=true;}
//else btEndSignals2.TurnOff();
}
else
{
if (TestFlag(iLights[1],2))
{btEndSignals21.TurnOn(); btnOn=true;}
//else btEndSignals21.TurnOff();
if (TestFlag(iLights[1],32))
{btEndSignals23.TurnOn(); btnOn=true;}
//else btEndSignals23.TurnOff();
}
}
//tablice blaszane:
if (TestFlag(iLights[0],64))
{btEndSignalsTab1.TurnOn(); btnOn=true;}
//else btEndSignalsTab1.TurnOff();
if (TestFlag(iLights[1],64))
{btEndSignalsTab2.TurnOn(); btnOn=true;}
//else btEndSignalsTab2.TurnOff();
//McZapkie-181002: krecenie wahaczem (korzysta z kata obrotu silnika)
if (iAnimType[ANIM_LEVERS])
for (int i=0;i<4;++i)
if (smWahacze[i])
smWahacze[i]->SetRotate(float3(1,0,0),fWahaczeAmp*cos(MoverParameters->eAngle));
if (Mechanik&&(Controller!=Humandriver))
{//rysowanie figurki mechanika
if (smMechanik0) //mechanik od strony sprzęgu 0
if (smMechanik1) //jak jest drugi, to pierwszego jedynie pokazujemy
smMechanik0->iVisible=MoverParameters->ActiveCab>0;
else
{//jak jest tylko jeden, to do drugiej kabiny go obracamy
smMechanik0->iVisible=(MoverParameters->ActiveCab!=0);
smMechanik0->SetRotate(float3(0,0,1),MoverParameters->ActiveCab>=0?0:180); //obrót względem osi Z
}
if (smMechanik1) //mechanik od strony sprzęgu 1
smMechanik1->iVisible=MoverParameters->ActiveCab<0;
}
//ABu: Przechyly na zakretach
//Ra: przechyłkę załatwiamy na etapie przesuwania modelu
//if (ObjSqrDist<80000) ABuModelRoll(); //przechyłki od 400m
}
if (MoverParameters->Battery)
{//sygnały czoła pociagu //Ra: wyświetlamy bez ograniczeń odległości, by były widoczne z daleka
if (TestFlag(iLights[0],1))
{btHeadSignals11.TurnOn(); btnOn=true;}
//else btHeadSignals11.TurnOff();
if (TestFlag(iLights[0],4))
{btHeadSignals12.TurnOn(); btnOn=true;}
//else btHeadSignals12.TurnOff();
if (TestFlag(iLights[0],16))
{btHeadSignals13.TurnOn(); btnOn=true;}
//else btHeadSignals13.TurnOff();
if (TestFlag(iLights[1],1))
{btHeadSignals21.TurnOn(); btnOn=true;}
//else btHeadSignals21.TurnOff();
if (TestFlag(iLights[1],4))
{btHeadSignals22.TurnOn(); btnOn=true;}
//else btHeadSignals22.TurnOff();
if (TestFlag(iLights[1],16))
{btHeadSignals23.TurnOn(); btnOn=true;}
//else btHeadSignals23.TurnOff();
}
}
//ABu 29.01.05 koniec przeklejenia *************************************
double __fastcall ABuAcos(const vector3 &calc_temp)
{ //Odpowiednik funkcji Arccos, bo cos mi tam nie dzialalo.
return atan2(-calc_temp.x,calc_temp.z); //Ra: tak prościej
}
TDynamicObject* __fastcall TDynamicObject::ABuFindNearestObject(TTrack *Track,TDynamicObject *MyPointer,int &CouplNr)
{//zwraca wskaznik do obiektu znajdujacego sie na torze (Track), którego sprzęg jest najblizszy kamerze
//służy np. do łączenia i rozpinania sprzęgów
//WE: Track - tor, na ktorym odbywa sie poszukiwanie
// MyPointer - wskaznik do obiektu szukajacego
//WY: CouplNr - który sprzęg znalezionego obiektu jest bliższy kamerze
//Uwaga! Jesli CouplNr==-2 to szukamy njblizszego obiektu, a nie sprzegu!!!
if ((Track->iNumDynamics)>0)
{//o ile w ogóle jest co przeglądać na tym torze
//vector3 poz; //pozycja pojazdu XYZ w scenerii
//vector3 kon; //wektor czoła względem środka pojazdu wzglęem początku toru
vector3 tmp; //wektor pomiędzy kamerą i sprzęgiem
double dist; //odległość
for (int i=0;i<Track->iNumDynamics;i++)
{
if (CouplNr==-2)
{//wektor [kamera-obiekt] - poszukiwanie obiektu
tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vPosition;
dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu
if (dist<100.0) //10 metrów
return Track->Dynamics[i];
}
else //jeśli (CouplNr) inne niz -2, szukamy sprzęgu
{//wektor [kamera-sprzeg0], potem [kamera-sprzeg1]
//Powinno byc wyliczone, ale nie zaszkodzi drugi raz:
//(bo co, jesli nie wykonuje sie obrotow wozkow?) - Ra: ale zawsze są liczone współrzędne sprzęgów
//Track->Dynamics[i]->modelRot.z=ABuAcos(Track->Dynamics[i]->Axle0.pPosition-Track->Dynamics[i]->Axle1.pPosition);
//poz=Track->Dynamics[i]->vPosition; //pozycja środka pojazdu
//kon=vector3( //położenie przodu względem środka
// -((0.5*Track->Dynamics[i]->MoverParameters->Dim.L)*sin(Track->Dynamics[i]->modelRot.z)),
// 0, //yyy... jeśli duże pochylenie i długi pojazd, to może być problem
// +((0.5*Track->Dynamics[i]->MoverParameters->Dim.L)*cos(Track->Dynamics[i]->modelRot.z))
//);
tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vCoulpler[0]; //Ra: pozycje sprzęgów też są zawsze liczone
dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu
if (dist<25.0) //5 metrów
{
CouplNr=0;
return Track->Dynamics[i];
}
tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vCoulpler[1];
dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu
if (dist<25.0) //5 metrów
{
CouplNr=1;
return Track->Dynamics[i];
}
}
}
return NULL;
}
return NULL;
}
TDynamicObject* __fastcall TDynamicObject::ABuScanNearestObject(TTrack *Track,double ScanDir,double ScanDist,int &CouplNr)
{//skanowanie toru w poszukiwaniu obiektu najblizszego kamerze
//double MyScanDir=ScanDir; //Moja orientacja na torze. //Ra: nie używane
if (ABuGetDirection()<0) ScanDir=-ScanDir;
TDynamicObject* FoundedObj;
FoundedObj=ABuFindNearestObject(Track,this,CouplNr); //zwraca numer sprzęgu znalezionego pojazdu
if (FoundedObj==NULL)
{
double ActDist; //Przeskanowana odleglosc.
double CurrDist=0; //Aktualna dlugosc toru.
if (ScanDir>=0) ActDist=Track->Length()-RaTranslationGet(); //???-przesunięcie wózka względem Point1 toru
else ActDist=RaTranslationGet(); //przesunięcie wózka względem Point1 toru
while (ActDist<ScanDist)
{
ActDist+=CurrDist;
if (ScanDir>0) //do przodu
{
if (Track->iNextDirection)
{
Track=Track->CurrentNext();
ScanDir=-ScanDir;
}
else
Track=Track->CurrentNext();
}
else //do tyłu
{
if (Track->iPrevDirection)
Track=Track->CurrentPrev();
else
{
Track=Track->CurrentPrev();
ScanDir=-ScanDir;
}
}
if (Track!=NULL)
{ //jesli jest kolejny odcinek toru
CurrDist=Track->Length();
FoundedObj=ABuFindNearestObject(Track, this, CouplNr);
if (FoundedObj!=NULL)
ActDist=ScanDist;
}
else //Jesli nie ma, to wychodzimy.
ActDist=ScanDist;
}
} //Koniec szukania najblizszego toru z jakims obiektem.
return FoundedObj;
}
//ABu 01.11.04 poczatek wyliczania przechylow pudla **********************
void __fastcall TDynamicObject::ABuModelRoll()
{//ustawienie przechyłki pojazdu i jego zawartości
// Ra: przechyłkę załatwiamy na etapie przesuwania modelu
}
//ABu 06.05.04 poczatek wyliczania obrotow wozkow **********************
void __fastcall TDynamicObject::ABuBogies()
{//Obracanie wozkow na zakretach. Na razie uwzględnia tylko zakręty,
//bez zadnych gorek i innych przeszkod.
if ((smBogie[0]!=NULL)&&(smBogie[1]!=NULL))
{
//modelRot.z=ABuAcos(Axle0.pPosition-Axle1.pPosition); //kąt obrotu pojazdu [rad]
//bogieRot[0].z=ABuAcos(Axle0.pPosition-Axle3.pPosition);
bogieRot[0].z=Axle0.vAngles.z;
bogieRot[0]=RadToDeg(modelRot-bogieRot[0]); //mnożenie wektora przez stałą
smBogie[0]->SetRotateXYZ(bogieRot[0]);
//bogieRot[1].z=ABuAcos(Axle2.pPosition-Axle1.pPosition);
bogieRot[1].z=Axle1.vAngles.z;
bogieRot[1]=RadToDeg(modelRot-bogieRot[1]);
smBogie[1]->SetRotateXYZ(bogieRot[1]);
}
};
//ABu 06.05.04 koniec wyliczania obrotow wozkow ************************
//ABu 16.03.03 sledzenie toru przed obiektem: **************************
void __fastcall TDynamicObject::ABuCheckMyTrack()
{//Funkcja przypisujaca obiekt prawidlowej tablicy Dynamics,
//bo gdzies jest jakis blad i wszystkie obiekty z danego
//pociagu na poczatku stawiane sa na jednym torze i wpisywane
//do jednej tablicy. Wykonuje sie tylko raz - po to 'ABuChecked'
TTrack* OldTrack=MyTrack;
TTrack* NewTrack=Axle0.GetTrack();
if ((NewTrack!=OldTrack)&&OldTrack)
{
OldTrack->RemoveDynamicObject(this);
NewTrack->AddDynamicObject(this);
}
iAxleFirst=0; //pojazd powiązany z przednią osią - Axle0
}
//Ra: w poniższej funkcji jest problem ze sprzęgami
TDynamicObject* __fastcall TDynamicObject::ABuFindObject(TTrack *Track,int ScanDir,Byte &CouplFound,double &dist)
{//Zwraca wskaźnik najbliższego obiektu znajdującego się
//na torze w określonym kierunku, ale tylko wtedy, kiedy
//obiekty mogą się zderzyć, tzn. nie mijają się.
//WE: Track - tor, na ktorym odbywa sie poszukiwanie,
// MyPointer - wskaznik do obiektu szukajacego. //Ra: zamieniłem na "this"
// ScanDir - kierunek szukania na torze (+1:w stronę Point2, -1:w stronę Point1)
// MyScanDir - kierunek szukania obiektu szukajacego (na jego torze); Ra: nie potrzebne
// MyCouplFound - nr sprzegu obiektu szukajacego; Ra: nie potrzebne
//WY: wskaznik do znalezionego obiektu.
// CouplFound - nr sprzegu znalezionego obiektu
if (Track->iNumDynamics>0)
{//sens szukania na tym torze jest tylko, gdy są na nim pojazdy
double ObjTranslation; //pozycja najblizszego obiektu na torze
double MyTranslation; //pozycja szukającego na torze
double MinDist=Track->Length(); //najmniejsza znaleziona odleglość (zaczynamy od długości toru)
double TestDist; //robocza odległość od kolejnych pojazdów na danym odcinku
int iMinDist=-1; //indeks wykrytego obiektu
//if (Track->iNumDynamics>1)
// iMinDist+=0; //tymczasowo pułapka
if (MyTrack==Track) //gdy szukanie na tym samym torze
MyTranslation=RaTranslationGet(); //położenie wózka względem Point1 toru
else //gdy szukanie na innym torze
if (ScanDir>0)
MyTranslation=0; //szukanie w kierunku Point2 (od zera) - jesteśmy w Point1
else
MyTranslation=MinDist; //szukanie w kierunku Point1 (do zera) - jesteśmy w Point2
if (ScanDir>=0)
{//jeśli szukanie w kierunku Point2
for (int i=0;i<Track->iNumDynamics;i++)
{//pętla po pojazdach
if (Track->Dynamics[i]!=this) //szukający się nie liczy
{
TestDist=(Track->Dynamics[i]->RaTranslationGet())-MyTranslation; //odległogłość tamtego od szukającego
if ((TestDist>0)&&(TestDist<=MinDist))
{//gdy jest po właściwej stronie i bliżej niż jakiś wcześniejszy
CouplFound=(Track->Dynamics[i]->RaDirectionGet()>0)?1:0; //to, bo (ScanDir>=0)
if (Track->iCategoryFlag&254) //trajektoria innego typu niż tor kolejowy
{//dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija
//Ra: mijanie samochodów wcale nie jest proste
// Przesuniecie wzgledne pojazdow. Wyznaczane, zeby sprawdzic,
// czy pojazdy faktycznie sie zderzaja (moga byc przesuniete
// w/m siebie tak, ze nie zachodza na siebie i wtedy sie mijaja).
double RelOffsetH; //wzajemna odległość poprzeczna
if (CouplFound) //my na tym torze byśmy byli w kierunku Point2
//dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć
RelOffsetH=(MoverParameters->OffsetTrackH-Track->Dynamics[i]->MoverParameters->OffsetTrackH);
else
//dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się
RelOffsetH=(MoverParameters->OffsetTrackH+Track->Dynamics[i]->MoverParameters->OffsetTrackH);
if (RelOffsetH<0) RelOffsetH=-RelOffsetH;
if (RelOffsetH+RelOffsetH>MoverParameters->Dim.W+Track->Dynamics[i]->MoverParameters->Dim.W)
continue; //odległość większa od połowy sumy szerokości - kolizji nie będzie
//jeśli zahaczenie jest niewielkie, a jest miejsce na poboczu, to zjechać na pobocze
}
iMinDist=i; //potencjalna kolizja
MinDist=TestDist; //odleglość pomiędzy aktywnymi osiami pojazdów
}
}
}
}
else //(ScanDir<0)
{
for (int i=0;i<Track->iNumDynamics;i++)
{
if (Track->Dynamics[i]!=this)
{
TestDist=MyTranslation-(Track->Dynamics[i]->RaTranslationGet()); //???-przesunięcie wózka względem Point1 toru
if ((TestDist>0)&&(TestDist<MinDist))
{
CouplFound=(Track->Dynamics[i]->RaDirectionGet()>0)?0:1; //odwrotnie, bo (ScanDir<0)
if (Track->iCategoryFlag&254) //trajektoria innego typu niż tor kolejowy
{//dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija
//Ra: mijanie samochodów wcale nie jest proste
// Przesunięcie względne pojazdów. Wyznaczane, żeby sprawdzić,
// czy pojazdy faktycznie się zderzają (mogą być przesunięte
// w/m siebie tak, że nie zachodzą na siebie i wtedy sie mijają).
double RelOffsetH; //wzajemna odległość poprzeczna
if (CouplFound) //my na tym torze byśmy byli w kierunku Point1
//dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć
RelOffsetH=(MoverParameters->OffsetTrackH-Track->Dynamics[i]->MoverParameters->OffsetTrackH);
else
//dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się
RelOffsetH=(MoverParameters->OffsetTrackH+Track->Dynamics[i]->MoverParameters->OffsetTrackH);
if (RelOffsetH<0) RelOffsetH=-RelOffsetH;
if (RelOffsetH+RelOffsetH>MoverParameters->Dim.W+Track->Dynamics[i]->MoverParameters->Dim.W)
continue; //odległość większa od połowy sumy szerokości - kolizji nie będzie
}
iMinDist=i; //potencjalna kolizja
MinDist=TestDist; //odleglość pomiędzy aktywnymi osiami pojazdów
}
}
}
}
dist+=MinDist; //doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości
return (iMinDist>=0)?Track->Dynamics[iMinDist]:NULL;
}
dist+=Track->Length(); //doliczenie długości odcinka do przeskanowanej odległości
return NULL; //nie ma pojazdów na torze, to jest NULL
}
int TDynamicObject::DettachStatus(int dir)
{//sprawdzenie odległości sprzęgów rzeczywistych od strony (dir): 0=przód,1=tył
//Ra: dziwne, że ta funkcja nie jest używana
if (!MoverParameters->Couplers[dir].CouplingFlag)
return 0; //jeśli nic nie podłączone, to jest OK
return (MoverParameters->DettachStatus(dir)); //czy jest w odpowiedniej odległości?
}
int TDynamicObject::Dettach(int dir)
{//rozłączenie sprzęgów rzeczywistych od strony (dir): 0=przód,1=tył
//zwraca maskę bitową aktualnych sprzegów (0 jeśli rozłączony)
if (ctOwner)
{//jeśli pojazd ma przypisany obiekt nadzorujący skład, to póki są wskaźniki
TDynamicObject *d=this;
while (d)
{
d->ctOwner=NULL; //usuwanie właściciela
d=d->Prev();
}
d=Next();
while (d)
{
d->ctOwner=NULL; //usuwanie właściciela
d=d->Next(); //i w drugą stronę
}
}
if (MoverParameters->Couplers[dir].CouplingFlag) //odczepianie, o ile coś podłączone
MoverParameters->Dettach(dir);
return MoverParameters->Couplers[dir].CouplingFlag; //sprzęg po rozłączaniu (czego się nie da odpiąć
}
void TDynamicObject::CouplersDettach(double MinDist,int MyScanDir)
{//funkcja rozłączajaca podłączone sprzęgi, jeśli odległość przekracza (MinDist)
//MinDist - dystans minimalny, dla ktorego mozna rozłączać
if (MyScanDir>0)
{
if (PrevConnected) //pojazd od strony sprzęgu 0
{
if (MoverParameters->Couplers[0].CoupleDist>MinDist) //sprzęgi wirtualne zawsze przekraczają
{
if ((PrevConnectedNo?PrevConnected->NextConnected:PrevConnected->PrevConnected)==this)
{//Ra: nie rozłączamy znalezionego, jeżeli nie do nas podłączony (może jechać w innym kierunku)
PrevConnected->MoverParameters->Couplers[PrevConnectedNo].Connected=NULL;
if (PrevConnectedNo==0)
{
PrevConnected->PrevConnectedNo=2; //sprzęg 0 nie podłączony
PrevConnected->PrevConnected=NULL;
}
else if (PrevConnectedNo==1)
{
PrevConnected->NextConnectedNo=2; //sprzęg 1 nie podłączony
PrevConnected->NextConnected=NULL;
}
}
//za to zawsze odłączamy siebie
PrevConnected=NULL;
PrevConnectedNo=2; //sprzęg 0 nie podłączony
MoverParameters->Couplers[0].Connected=NULL;
}
}
}
else
{
if (NextConnected) //pojazd od strony sprzęgu 1
{
if (MoverParameters->Couplers[1].CoupleDist>MinDist) //sprzęgi wirtualne zawsze przekraczają
{
if ((NextConnectedNo?NextConnected->NextConnected:NextConnected->PrevConnected)==this)
{//Ra: nie rozłączamy znalezionego, jeżeli nie do nas podłączony (może jechać w innym kierunku)
NextConnected->MoverParameters->Couplers[NextConnectedNo].Connected=NULL;
if (NextConnectedNo==0)
{
NextConnected->PrevConnectedNo=2; //sprzęg 0 nie podłączony
NextConnected->PrevConnected=NULL;
}
else if (NextConnectedNo==1)
{
NextConnected->NextConnectedNo=2; //sprzęg 1 nie podłączony
NextConnected->NextConnected=NULL;
}
}
NextConnected=NULL;
NextConnectedNo=2; //sprzęg 1 nie podłączony
MoverParameters->Couplers[1].Connected=NULL;
}
}
}
}
void TDynamicObject::ABuScanObjects(int ScanDir,double ScanDist)
{//skanowanie toru w poszukiwaniu kolidujących pojazdów
//ScanDir - określa kierunek poszukiwania zależnie od zwrotu prędkości pojazdu
// ScanDir=1 - od strony Coupler0, ScanDir=-1 - od strony Coupler1
int MyScanDir=ScanDir; //zapamiętanie kierunku poszukiwań na torze początkowym, względem sprzęgów
TTrackFollower *FirstAxle=(MyScanDir>0?&Axle0:&Axle1); //można by to trzymać w trainset
TTrack *Track=FirstAxle->GetTrack(); //tor na którym "stoi" skrajny wózek (może być inny niż tor pojazdu)
if (FirstAxle->GetDirection()<0) //czy oś jest ustawiona w stronę Point1?
ScanDir=-ScanDir; //jeśli tak, to kierunek szukania będzie przeciwny (teraz względem toru)
Byte MyCouplFound; //numer sprzęgu do podłączenia w obiekcie szukajacym
MyCouplFound=(MyScanDir<0)?1:0;
Byte CouplFound; //numer sprzęgu w znalezionym obiekcie (znaleziony wypełni)
TDynamicObject *FoundedObj; //znaleziony obiekt
double ActDist=0; //przeskanowana odleglość; odległość do zawalidrogi
FoundedObj=ABuFindObject(Track,ScanDir,CouplFound,ActDist); //zaczynamy szukać na tym samym torze
/*
if (FoundedObj) //jak coś znajdzie, to śledzimy
{//powtórzenie wyszukiwania tylko do zastawiania pułepek podczas testów
if (ABuGetDirection()<0) ScanDir=ScanDir; //ustalenie kierunku względem toru
FoundedObj=ABuFindObject(Track,this,ScanDir,CouplFound);
}
*/
if (DebugModeFlag)
if (FoundedObj) //kod służący do logowania błędów
if (CouplFound==0)
{
if (FoundedObj->PrevConnected)
if (FoundedObj->PrevConnected!=this) //odświeżenie tego samego się nie liczy
WriteLog("0! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":0 connected to "+FoundedObj->PrevConnected->asName+":"+AnsiString(FoundedObj->PrevConnectedNo));
}
else
{
if (FoundedObj->NextConnected)
if (FoundedObj->NextConnected!=this) //odświeżenie tego samego się nie liczy
WriteLog("0! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":1 connected to "+FoundedObj->NextConnected->asName+":"+AnsiString(FoundedObj->NextConnectedNo));
}
if (FoundedObj==NULL) //jeśli nie ma na tym samym, szukamy po okolicy
{//szukanie najblizszego toru z jakims obiektem
//praktycznie przeklejone z TraceRoute()...
//double CurrDist=0; //aktualna dlugosc toru
if (ScanDir>=0) //uwzględniamy kawalek przeanalizowanego wcześniej toru
ActDist=Track->Length()-FirstAxle->GetTranslation(); //odległość osi od Point2 toru
else
ActDist=FirstAxle->GetTranslation(); //odległość osi od Point1 toru
while (ActDist<ScanDist)
{
//ActDist+=CurrDist; //odległość już przeanalizowana
if (ScanDir>0) //w kierunku Point2 toru
{
if (Track?Track->iNextDirection:false) //jeśli następny tor jest podpięty od Point2
ScanDir=-ScanDir; //to zmieniamy kierunek szukania na tym torze
Track=Track->CurrentNext(); //potem dopiero zmieniamy wskaźnik
}
else //w kierunku Point1
{
if (Track?!Track->iPrevDirection:true) //jeśli poprzedni tor nie jest podpięty od Point2
ScanDir=-ScanDir; //to zmieniamy kierunek szukania na tym torze
Track=Track->CurrentPrev(); //potem dopiero zmieniamy wskaźnik
}
if (Track)
{//jesli jest kolejny odcinek toru
//CurrDist=Track->Length(); //doliczenie tego toru do przejrzanego dystandu
FoundedObj=ABuFindObject(Track,ScanDir,CouplFound,ActDist); //przejrzenie pojazdów tego toru
if (FoundedObj)
{
//ActDist=ScanDist; //wyjście z pętli poszukiwania
break;
}
}
else //jeśli toru nie ma, to wychodzimy
{
ActDist=ScanDist+1.0; //koniec przeglądania torów
break;
}
}
} // Koniec szukania najbliższego toru z jakimś obiektem.
//teraz odczepianie i jeśli coś się znalazło, doczepianie.
if (MyScanDir>0?PrevConnected:NextConnected)
if ((MyScanDir>0?PrevConnected:NextConnected)!=FoundedObj)
CouplersDettach(1.0,MyScanDir); //odłączamy, jeśli dalej niż metr
// i łączenie sprzęgiem wirtualnym
if (FoundedObj)
{//siebie można bezpiecznie podłączyć jednostronnie do znalezionego
MoverParameters->Attach(MyCouplFound,CouplFound,FoundedObj->MoverParameters,ctrain_virtual);
//MoverParameters->Couplers[MyCouplFound].Render=false; //wirtualnego nie renderujemy
if (MyCouplFound==0)
{
PrevConnected=FoundedObj; //pojazd od strony sprzęgu 0
PrevConnectedNo=CouplFound;
}
else
{
NextConnected=FoundedObj; //pojazd od strony sprzęgu 1
NextConnectedNo=CouplFound;
}
if (FoundedObj->MoverParameters->Couplers[CouplFound].CouplingFlag==ctrain_virtual)
{//Ra: wpinamy się wirtualnym tylko jeśli znaleziony ma wirtualny sprzęg
FoundedObj->MoverParameters->Attach(CouplFound,MyCouplFound,this->MoverParameters,ctrain_virtual);
if (CouplFound==0) //jeśli widoczny sprzęg 0 znalezionego
{
if (DebugModeFlag)
if (FoundedObj->PrevConnected)
if (FoundedObj->PrevConnected!=this)
WriteLog("1! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":0 connected to "+FoundedObj->PrevConnected->asName+":"+AnsiString(FoundedObj->PrevConnectedNo));
FoundedObj->PrevConnected=this;
FoundedObj->PrevConnectedNo=MyCouplFound;
}
else //jeśli widoczny sprzęg 1 znalezionego
{
if (DebugModeFlag)
if (FoundedObj->NextConnected)
if (FoundedObj->NextConnected!=this)
WriteLog("1! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":1 connected to "+FoundedObj->NextConnected->asName+":"+AnsiString(FoundedObj->NextConnectedNo));
FoundedObj->NextConnected=this;
FoundedObj->NextConnectedNo=MyCouplFound;
}
}
//Ra: jeśli dwa samochody się mijają na odcinku przed zawrotką, to odległość między nimi nie może być liczona w linii prostej!
fTrackBlock=MoverParameters->Couplers[MyCouplFound].CoupleDist; //odległość do najbliższego pojazdu w linii prostej
if (Track->iCategoryFlag>1) //jeśli samochód
if (ActDist>MoverParameters->Dim.L+FoundedObj->MoverParameters->Dim.L) //przeskanowana odległość większa od długości pojazdów
//else if (ActDist<ScanDist) //dla samochodów musi być uwzględniona droga do zawrócenia
fTrackBlock=ActDist; //ta odległość jest wiecej warta
//if (fTrackBlock<500.0)
// WriteLog("Collision of "+AnsiString(fTrackBlock)+"m detected by "+asName+":"+AnsiString(MyCouplFound)+" with "+FoundedObj->asName);
}
else //nic nie znalezione, to nie ma przeszkód
fTrackBlock=10000.0;
}
//----------ABu: koniec skanowania pojazdow
__fastcall TDynamicObject::TDynamicObject()
{
modelShake=vector3(0,0,0);
fTrackBlock=10000.0; //brak przeszkody na drodze
btnOn=false;
vUp=vWorldUp;
vFront=vWorldFront;
vLeft=vWorldLeft;
iNumAxles=0;
MoverParameters=NULL;
Mechanik=NULL;
MechInside=false;
//McZapkie-270202
Controller=AIdriver;
bDisplayCab=false; //030303
bBrakeAcc=false;
NextConnected=PrevConnected=NULL;
NextConnectedNo=PrevConnectedNo=2; //ABu: Numery sprzegow. 2=nie podłączony
CouplCounter=50; //będzie sprawdzać na początku
asName="";
bEnabled=true;
MyTrack=NULL;
//McZapkie-260202
dRailLength=25.0;
for (int i=0;i<MaxAxles;i++)
dRailPosition[i]=0.0;
for (int i=0;i<MaxAxles;i++)
dWheelsPosition[i]=0.0; //będzie wczytane z MMD
iAxles=0;
dWheelAngle[0]=0.0;
dWheelAngle[1]=0.0;
dWheelAngle[2]=0.0;
//Winger 160204 - pantografy
//PantVolume = 3.5;
NoVoltTime=0;
dDoorMoveL=0.0;
dDoorMoveR=0.0;
//for (int i=0;i<8;i++)
//{
// DoorSpeedFactor[i]=random(150);
// DoorSpeedFactor[i]=(DoorSpeedFactor[i]+100)/100;
//}
mdModel=NULL;
mdKabina=NULL;
ReplacableSkinID[0]=0;
ReplacableSkinID[1]=0;
ReplacableSkinID[2]=0;
ReplacableSkinID[3]=0;
ReplacableSkinID[4]=0;
iAlpha=0x30300030; //tak gdy tekstury wymienne nie mają przezroczystości
//smWiazary[0]=smWiazary[1]=NULL;
smWahacze[0]=smWahacze[1]=smWahacze[2]=smWahacze[3]=NULL;
fWahaczeAmp=0;
smBrakeMode=NULL;
smLoadMode=NULL;
mdLoad=NULL;
mdLowPolyInt=NULL;
mdPrzedsionek=NULL;
smMechanik0=smMechanik1=NULL;
smBuforLewy[0]=smBuforLewy[1]=NULL;
smBuforPrawy[0]=smBuforPrawy[1]=NULL;
enginevolume=0;
smBogie[0]=smBogie[1]=NULL;
bogieRot[0]=bogieRot[1]=vector3(0,0,0);
modelRot=vector3(0,0,0);
eng_vol_act=0.8;
eng_dfrq=0;
eng_frq_act=1;
eng_turbo=0;
cp1=cp2=sp1=sp2=0;
iDirection=1; //stoi w kierunku tradycyjnym (0, gdy jest odwrócony)
iAxleFirst=0; //numer pierwszej osi w kierunku ruchu (przełączenie następuje, gdy osie sa na tym samym torze)
iInventory=0; //flagi bitowe posiadanych submodeli (zaktualizuje się po wczytaniu MMD)
RaLightsSet(0,0); //początkowe zerowanie stanu świateł
//Ra: domyślne ilości animacji dla zgodności wstecz (gdy brak ilości podanych w MMD)
iAnimType[ANIM_WHEELS ]=8; //0-osie (8)
iAnimType[ANIM_DOORS ]=8; //1-drzwi (8)
iAnimType[ANIM_LEVERS ]=4; //2-wahacze (4) - np. nogi konia
iAnimType[ANIM_BUFFERS]=4; //3-zderzaki (4)
iAnimType[ANIM_BOOGIES]=2; //4-wózki (2)
iAnimType[ANIM_PANTS ]=2; //5-pantografy (2)
iAnimType[ANIM_STEAMS ]=0; //6-tłoki (napęd parowozu)
iAnimations=0; //na razie nie ma żadnego
pAnimations=NULL;
pAnimated=NULL;
fShade=0.0; //standardowe oświetlenie na starcie
iHornWarning=1; //numer syreny do użycia po otrzymaniu sygnału do jazdy
asDestination="none"; //stojący nigdzie nie jedzie
pValveGear=NULL; //Ra: tymczasowo
iCabs=0; //maski bitowe modeli kabin
smBrakeSet=NULL; //nastawa hamulca (wajcha)
smLoadSet=NULL; //nastawa ładunku (wajcha)
smWiper=NULL; //wycieraczka (poniekąd też wajcha)
fScanDist=300.0; //odległość skanowania, zwiększana w trybie łączenia
ctOwner=NULL; //na początek niczyj
iOverheadMask=0; //maska przydzielana przez AI pojazdom posiadającym pantograf, aby wymuszały jazdę bezprądową
tmpTraction.TractionVoltage=0; //Ra 2F1H: prowizorka, trzeba przechować napięcie, żeby nie wywalało WS pod izolatorem
fAdjustment=0.0; //korekcja odległości pomiędzy wózkami (np. na łukach)
}
__fastcall TDynamicObject::~TDynamicObject()
{//McZapkie-250302 - zamykanie logowania parametrow fizycznych
SafeDelete(Mechanik);
SafeDelete(MoverParameters);
//Ra: wyłączanie dźwięków powinno być dodane w ich destruktorach, ale się sypie
/* to też się sypie
for (int i=0;i<MaxAxles;++i)
rsStukot[i].Stop(); //dzwieki poszczegolnych osi
rsSilnik.Stop();
rsWentylator.Stop();
rsPisk.Stop();
rsDerailment.Stop();
sPantUp.Stop();
sPantDown.Stop();
sBrakeAcc.Stop(); //dzwiek przyspieszacza
rsDiesielInc.Stop();
rscurve.Stop();
*/
delete[] pAnimations; //obiekty obsługujące animację
delete[] pAnimated; //lista animowanych submodeli
}
double __fastcall TDynamicObject::Init(
AnsiString Name, //nazwa pojazdu, np. "EU07-424"
AnsiString BaseDir, //z którego katalogu wczytany, np. "PKP/EU07"
AnsiString asReplacableSkin, //nazwa wymiennej tekstury
AnsiString Type_Name, //nazwa CHK/MMD, np. "303E"
TTrack *Track, //tor początkowy wstwawienia (początek składu)
double fDist, //dystans względem punktu 1
AnsiString DriverType, //typ obsady
double fVel, //prędkość początkowa
AnsiString TrainName, //nazwa składu, np. "PE2307" albo Vmax, jeśli pliku nie ma a są cyfry
float Load, //ilość ładunku
AnsiString LoadType, //nazwa ładunku
bool Reversed, //true, jeśli ma stać odwrotnie w składzie
AnsiString MoreParams //dodatkowe parametry wczytywane w postaci tekstowej
)
{//Ustawienie początkowe pojazdu
iDirection=(Reversed?0:1); //Ra: 0, jeśli ma być wstawiony jako obrócony tyłem
asBaseDir="dynamic\\"+BaseDir+"\\"; //McZapkie-310302
asName=Name;
AnsiString asAnimName=""; //zmienna robocza do wyszukiwania osi i wózków
//Ra: zmieniamy znaczenie obsady na jednoliterowe, żeby dosadzić kierownika
if (DriverType=="headdriver") DriverType="1"; //sterujący kabiną +1
else if (DriverType=="reardriver") DriverType="2"; //sterujący kabiną -1
//else if (DriverType=="connected") DriverType="c"; //tego trzeba się pozbyć na rzecz ukrotnienia
else if (DriverType=="passenger") DriverType="p"; //to do przemyślenia
else if (DriverType=="nobody") DriverType=""; //nikt nie siedzi
int Cab=0; //numer kabiny z obsadą (nie można zająć obu)
if (DriverType.Pos("1")) //od przodu składu
Cab=1;//iDirection?1:-1; //iDirection=1 gdy normalnie, =0 odwrotnie
else if (DriverType.Pos("2")) //od tyłu składu
Cab=-1;//iDirection?-1:1;
else if (DriverType=="p")
{
if (random(6)<3) Cab=1; else Cab=-1; //losowy przydział kabiny
}
/* to nie ma uzasadnienia
else
{//obsada nie rozpoznana
Cab=0; //McZapkie-010303: w przyszlosci dac tez pomocnika, palacza, konduktora itp.
Error("Unknown DriverType description: "+DriverType);
DriverType="nobody";
}
*/
//utworzenie parametrów fizyki
MoverParameters=new TMoverParameters(iDirection?fVel:-fVel,Type_Name,asName,Load,LoadType,Cab);
iLights=MoverParameters->iLights; //wskaźnik na stan własnych świateł (zmienimy dla rozrządczych EZT)
//McZapkie: TypeName musi byc nazwą CHK/MMD pojazdu
if (!MoverParameters->LoadChkFile(asBaseDir))
{//jak wczytanie CHK się nie uda, to błąd
if (ConversionError==-8)
ErrorLog("Missed file: "+BaseDir+"\\"+Type_Name+".fiz");
Error("Cannot load dynamic object "+asName+" from:\r\n"+BaseDir+"\\"+Type_Name+".fiz\r\nError "+ConversionError+" in line "+LineCount);
return 0.0; //zerowa długość to brak pojazdu
}
bool driveractive=(fVel!=0.0); //jeśli prędkość niezerowa, to aktywujemy ruch
if (!MoverParameters->CheckLocomotiveParameters(driveractive,(fVel>0?1:-1)*Cab*(iDirection?1:-1))) //jak jedzie lub obsadzony to gotowy do drogi
{
Error("Parameters mismatch: dynamic object "+asName+" from\n"+BaseDir+"\\"+Type_Name);
return 0.0; //zerowa długość to brak pojazdu
}
MoverParameters->BrakeLevelSet(MoverParameters->BrakeCtrlPos); //poprawienie hamulca po ewentualnym przestawieniu przez Pascal
//dodatkowe parametry yB
MoreParams+="."; //wykonuje o jedną iterację za mało, więc trzeba mu dodać kropkę na koniec
int kropka=MoreParams.Pos("."); //znajdź kropke
AnsiString ActPar; //na parametry
while (kropka>0) //jesli sa kropki jeszcze
{
int dlugosc=MoreParams.Length();
ActPar=MoreParams.SubString(1,kropka-1).UpperCase(); //pierwszy parametr;
MoreParams=MoreParams.SubString(kropka+1,dlugosc-kropka); //reszta do dalszej obrobki
kropka=MoreParams.Pos(".");
if(ActPar.SubString(1,1)=="B") //jesli hamulce
{ //sprawdzanie kolejno nastaw
WriteLog("Wpis hamulca: " + ActPar);
if (ActPar.Pos("G")>0) {MoverParameters->BrakeDelaySwitch(bdelay_G);}
if (ActPar.Pos("P")>0) {MoverParameters->BrakeDelaySwitch(bdelay_P);}
if (ActPar.Pos("R")>0) {MoverParameters->BrakeDelaySwitch(bdelay_R);}
if (ActPar.Pos("M")>0) {MoverParameters->BrakeDelaySwitch(bdelay_R); MoverParameters->BrakeDelaySwitch(bdelay_R+bdelay_M);}
//wylaczanie hamulca
if (ActPar.Pos("<>")>0) //wylaczanie na probe hamowania naglego
{
MoverParameters->BrakeStatus|=128; //wylacz
}
if (ActPar.Pos("0")>0) //wylaczanie na sztywno
{
MoverParameters->BrakeStatus|=128; //wylacz
MoverParameters->Hamulec->ForceEmptiness();
MoverParameters->BrakeReleaser(1); //odluznij automatycznie
}
if (ActPar.Pos("E")>0) //oprozniony
{
MoverParameters->Hamulec->ForceEmptiness();
MoverParameters->BrakeReleaser(1); //odluznij automatycznie
MoverParameters->Pipe->CreatePress(0);
MoverParameters->Pipe2->CreatePress(0);
}
if (ActPar.Pos("Q")>0) //oprozniony
{
// MoverParameters->Hamulec->ForceEmptiness(); //TODO: sprawdzic, dlaczego pojawia sie blad przy uzyciu tej linijki w lokomotywie
MoverParameters->BrakeReleaser(1); //odluznij automatycznie
MoverParameters->Pipe->CreatePress(0.0);
MoverParameters->PipePress=0.0;
MoverParameters->Pipe2->CreatePress(0.0);
MoverParameters->ScndPipePress=0.0;
MoverParameters->PantVolume=1;
MoverParameters->PantPress=0;
MoverParameters->CompressedVolume=0;
}
if (ActPar.Pos("1")>0) //wylaczanie 10%
{
if (random(10)<1) //losowanie 1/10
{
MoverParameters->BrakeStatus|=128; //wylacz
MoverParameters->Hamulec->ForceEmptiness();
MoverParameters->BrakeReleaser(1); //odluznij automatycznie
}
}
if (ActPar.Pos("X")>0) //agonalny wylaczanie 20%, usrednienie przekladni
{
if (random(100)<20) //losowanie 20/100
{
MoverParameters->BrakeStatus|=128; //wylacz
MoverParameters->Hamulec->ForceEmptiness();
MoverParameters->BrakeReleaser(1); //odluznij automatycznie
}
if (MoverParameters->BrakeCylMult[2]*MoverParameters->BrakeCylMult[1]>0.01) //jesli jest nastawiacz mechaniczny PL
{
float rnd=random(100);
if (rnd<20) //losowanie 20/100 usrednienie
{
MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[1]=(MoverParameters->BrakeCylMult[2]+MoverParameters->BrakeCylMult[1])/2;
}
else
if (rnd<70) //losowanie 70/100-20/100 oslabienie
{
MoverParameters->BrakeCylMult[1]=MoverParameters->BrakeCylMult[1]*0.50;
MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[2]*0.75;
}
else
if (rnd<80) //losowanie 80/100-70/100 tylko prozny
{
MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[1];
}
else //tylko ladowny
{
MoverParameters->BrakeCylMult[1]=MoverParameters->BrakeCylMult[2];
}
}
}
//nastawianie ladunku
if (ActPar.Pos("T")>0) //prozny
{ MoverParameters->DecBrakeMult(); MoverParameters->DecBrakeMult(); } //dwa razy w dol
if (ActPar.Pos("H")>0) //ladowny I (dla P-Ł dalej prozny)
{ MoverParameters->IncBrakeMult(); MoverParameters->IncBrakeMult(); MoverParameters->DecBrakeMult(); } //dwa razy w gore i obniz
if (ActPar.Pos("F")>0) //ladowny II
{ MoverParameters->IncBrakeMult(); MoverParameters->IncBrakeMult(); } //dwa razy w gore
if (ActPar.Pos("N")>0) //parametr neutralny
{ }
} //koniec hamulce
else if(ActPar.SubString(1,1)=="") //tu mozna wpisac inny prefiks i inne rzeczy
{
//jakies inne prefiksy
}
} //koniec while kropka
if (MoverParameters->CategoryFlag&2) //jeśli samochód
{//ustawianie samochodow na poboczu albo na środku drogi
if (Track->fTrackWidth<3.5) //jeśli droga wąska
MoverParameters->OffsetTrackH=0.0; //to stawiamy na środku, niezależnie od stanu ruchu
else
if (driveractive) //od 3.5m do 8.0m jedzie po środku pasa, dla szerszych w odległości 1.5m
MoverParameters->OffsetTrackH=Track->fTrackWidth<=8.0?-Track->fTrackWidth*0.25:-1.5;
else //jak stoi, to kołem na poboczu i pobieramy szerokość razem z poboczem, ale nie z chodnikiem
MoverParameters->OffsetTrackH=-0.5*(Track->WidthTotal()-MoverParameters->Dim.W)+0.05;
iHornWarning=0; //nie będzie trąbienia po podaniu zezwolenia na jazdę
if (fDist<0.0) //-0.5*MoverParameters->Dim.L) //jeśli jest przesunięcie do tyłu
if (!Track->CurrentPrev()) //a nie ma tam odcinka i trzeba by coś wygenerować
fDist=-fDist; //to traktujemy, jakby przesunięcie było w drugą stronę
}
//w wagonie tez niech jedzie
//if (MoverParameters->MainCtrlPosNo>0 &&
// if (MoverParameters->CabNo!=0)
if (DriverType!="")
{//McZapkie-040602: jeśli coś siedzi w pojeździe
if (Name==AnsiString(Global::asHumanCtrlVehicle)) //jeśli pojazd wybrany do prowadzenia
{
if (DebugModeFlag?false:MoverParameters->EngineType!=Dumb) //jak nie Debugmode i nie jest dumbem
Controller=Humandriver; //wsadzamy tam sterującego
else //w przeciwnym razie trzeba włączyć pokazywanie kabiny
bDisplayCab=true;
}
//McZapkie-151102: rozkład jazdy czytany z pliku *.txt z katalogu w którym jest sceneria
if (DriverType.Pos("1")||DriverType.Pos("2"))
{//McZapkie-110303: mechanik i rozklad tylko gdy jest obsada
//MoverParameters->ActiveCab=MoverParameters->CabNo; //ustalenie aktywnej kabiny (rozrząd)
Mechanik=new TController(Controller,this,Aggressive);
if (TrainName.IsEmpty()) //jeśli nie w składzie
{
Mechanik->DirectionInitial(); //załączenie rozrządu (wirtualne kabiny) itd.
Mechanik->PutCommand("Timetable:",iDirection?-fVel:fVel,0,NULL); //tryb pociągowy z ustaloną prędkością (względem sprzęgów)
}
//if (TrainName!="none")
// Mechanik->PutCommand("Timetable:"+TrainName,fVel,0,NULL);
}
else
if (DriverType=="p")
{//obserwator w charakterze pasażera
//Ra: to jest niebezpieczne, bo w razie co będzie pomagał hamulcem bezpieczeństwa
Mechanik=new TController(Controller,this,Easyman,false);
}
}
// McZapkie-250202
iAxles=(MaxAxles<MoverParameters->NAxles)?MaxAxles:MoverParameters->NAxles; //ilość osi
//wczytywanie z pliku nazwatypu.mmd, w tym model
LoadMMediaFile(asBaseDir,Type_Name,asReplacableSkin);
//McZapkie-100402: wyszukiwanie submodeli sprzegów
btCoupler1.Init("coupler1",mdModel,false); //false - ma być wyłączony
btCoupler2.Init("coupler2",mdModel,false);
btCPneumatic1.Init("cpneumatic1",mdModel);
btCPneumatic2.Init("cpneumatic2",mdModel);
btCPneumatic1r.Init("cpneumatic1r",mdModel);
btCPneumatic2r.Init("cpneumatic2r",mdModel);
btPneumatic1.Init("pneumatic1",mdModel);
btPneumatic2.Init("pneumatic2",mdModel);
btPneumatic1r.Init("pneumatic1r",mdModel);
btPneumatic2r.Init("pneumatic2r",mdModel);
btCCtrl1.Init("cctrl1",mdModel,false);
btCCtrl2.Init("cctrl2",mdModel,false);
btCPass1.Init("cpass1",mdModel,false);
btCPass2.Init("cpass2",mdModel,false);
//sygnaly
//ABu 060205: Zmiany dla koncowek swiecacych:
btEndSignals11.Init("endsignal13",mdModel,false);
btEndSignals21.Init("endsignal23",mdModel,false);
btEndSignals13.Init("endsignal12",mdModel,false);
btEndSignals23.Init("endsignal22",mdModel,false);
iInventory|=btEndSignals11.Active() ?0x01:0; //informacja, czy ma poszczególne światła
iInventory|=btEndSignals21.Active() ?0x02:0;
iInventory|=btEndSignals13.Active() ?0x04:0;
iInventory|=btEndSignals23.Active() ?0x08:0;
//ABu: to niestety zostawione dla kompatybilnosci modeli:
btEndSignals1.Init("endsignals1",mdModel,false);
btEndSignals2.Init("endsignals2",mdModel,false);
btEndSignalsTab1.Init("endtab1",mdModel,false);
btEndSignalsTab2.Init("endtab2",mdModel,false);
iInventory|=btEndSignals1.Active() ?0x10:0;
iInventory|=btEndSignals2.Active() ?0x20:0;
iInventory|=btEndSignalsTab1.Active()?0x40:0; //tabliczki blaszane
iInventory|=btEndSignalsTab2.Active()?0x80:0;
//ABu Uwaga! tu zmienic w modelu!
btHeadSignals11.Init("headlamp13",mdModel,false); //lewe
btHeadSignals12.Init("headlamp11",mdModel,false); //górne
btHeadSignals13.Init("headlamp12",mdModel,false); //prawe
btHeadSignals21.Init("headlamp23",mdModel,false);
btHeadSignals22.Init("headlamp21",mdModel,false);
btHeadSignals23.Init("headlamp22",mdModel,false);
TurnOff(); //resetowanie zmiennych submodeli
//wyszukiwanie zderzakow
if (mdModel) //jeśli ma w czym szukać
for (int i=0;i<2;i++)
{
asAnimName=AnsiString("buffer_left0")+(i+1);
smBuforLewy[i]=mdModel->GetFromName(asAnimName.c_str());
if (smBuforLewy[i])
smBuforLewy[i]->WillBeAnimated(); //ustawienie flagi animacji
asAnimName=AnsiString("buffer_right0")+(i+1);
smBuforPrawy[i]=mdModel->GetFromName(asAnimName.c_str());
if (smBuforPrawy[i])
smBuforPrawy[i]->WillBeAnimated();
}
for (int i=0;i<iAxles;i++) //wyszukiwanie osi (0 jest na końcu, dlatego dodajemy długość?)
dRailPosition[i]=(Reversed?-dWheelsPosition[i]:(dWheelsPosition[i]+MoverParameters->Dim.L))+fDist;
//McZapkie-250202 end.
Track->AddDynamicObject(this); //wstawiamy do toru na pozycję 0, a potem przesuniemy
//McZapkie: zmieniono na ilosc osi brane z chk
//iNumAxles=(MoverParameters->NAxles>3 ? 4 : 2 );
iNumAxles=2;
//McZapkie-090402: odleglosc miedzy czopami skretu lub osiami
fAxleDist=Max0R(MoverParameters->BDist,MoverParameters->ADist);
if (fAxleDist<0.2) fAxleDist=0.2; //żeby się dało wektory policzyć
if (fAxleDist>MoverParameters->Dim.L-0.2) //nie mogą być za daleko
fAxleDist=MoverParameters->Dim.L-0.2; //bo będzie "walenie w mur"
double fAxleDistHalf=fAxleDist*0.5;
//WriteLog("Dynamic "+Type_Name+" of length "+MoverParameters->Dim.L+" at "+AnsiString(fDist));
//if (Cab) //jeśli ma obsadę - zgodność wstecz, jeśli tor startowy ma Event0
// if (Track->Event0) //jeśli tor ma Event0
// if (fDist>=0.0) //jeśli jeśli w starych sceneriach początek składu byłby wysunięty na ten tor
// if (fDist<=0.5*MoverParameters->Dim.L+0.2) //ale nie jest wysunięty
// fDist+=0.5*MoverParameters->Dim.L+0.2; //wysunąć go na ten tor
//przesuwanie pojazdu tak, aby jego początek był we wskazanym miejcu
fDist-=0.5*MoverParameters->Dim.L; //dodajemy pół długości pojazdu, bo ustawiamy jego środek (zliczanie na minus)
switch (iNumAxles)
{//Ra: pojazdy wstawiane są na tor początkowy, a potem przesuwane
case 2: //ustawianie osi na torze
Axle0.Init(Track,this,iDirection?1:-1);
Axle0.Move((iDirection?fDist:-fDist)+fAxleDistHalf,false);
Axle1.Init(Track,this,iDirection?1:-1);
Axle1.Move((iDirection?fDist:-fDist)-fAxleDistHalf,false); //false, żeby nie generować eventów
//Axle2.Init(Track,this,iDirection?1:-1);
//Axle2.Move((iDirection?fDist:-fDist)-fAxleDistHalft+0.01),false);
//Axle3.Init(Track,this,iDirection?1:-1);
//Axle3.Move((iDirection?fDist:-fDist)+fAxleDistHalf-0.01),false);
break;
case 4:
Axle0.Init(Track,this,iDirection?1:-1);
Axle0.Move((iDirection?fDist:-fDist)+(fAxleDistHalf+MoverParameters->ADist*0.5),false);
Axle1.Init(Track,this,iDirection?1:-1);
Axle1.Move((iDirection?fDist:-fDist)-(fAxleDistHalf+MoverParameters->ADist*0.5),false);
//Axle2.Init(Track,this,iDirection?1:-1);
//Axle2.Move((iDirection?fDist:-fDist)-(fAxleDistHalf-MoverParameters->ADist*0.5),false);
//Axle3.Init(Track,this,iDirection?1:-1);
//Axle3.Move((iDirection?fDist:-fDist)+(fAxleDistHalf-MoverParameters->ADist*0.5),false);
break;
}
Move(0.0001); //potrzebne do wyliczenia aktualnej pozycji; nie może być zero, bo nie przeliczy pozycji
//teraz jeszcze trzeba przypisać pojazdy do nowego toru, bo przesuwanie początkowe osi nie zrobiło tego
ABuCheckMyTrack(); //zmiana toru na ten, co oś Axle0 (oś z przodu)
TLocation loc; //Ra: ustawienie pozycji do obliczania sprzęgów
loc.X=-vPosition.x;
loc.Y=vPosition.z;
loc.Z=vPosition.y;
MoverParameters->Loc=loc; //normalnie przesuwa ComputeMovement() w Update()
//pOldPos4=Axle1.pPosition; //Ra: nie używane
//pOldPos1=Axle0.pPosition;
//ActualTrack= GetTrack(); //McZapkie-030303
//ABuWozki 060504
if (mdModel) //jeśli ma w czym szukać
{
smBogie[0]=mdModel->GetFromName("bogie1"); //Ra: bo nazwy są małymi
smBogie[1]=mdModel->GetFromName("bogie2");
if (!smBogie[0])
smBogie[0]=mdModel->GetFromName("boogie01"); //Ra: alternatywna nazwa
if (!smBogie[1])
smBogie[1]=mdModel->GetFromName("boogie02"); //Ra: alternatywna nazwa
if (smBogie[0])
smBogie[0]->WillBeAnimated();
if (smBogie[1])
smBogie[1]->WillBeAnimated();
}
//ABu: zainicjowanie zmiennej, zeby nic sie nie ruszylo
//w pierwszej klatce, potem juz liczona prawidlowa wartosc masy
MoverParameters->ComputeConstans();
/*Ra: to nie działa - Event0 musi być wykonywany ciągle
if (fVel==0.0) //jeśli stoi
if (MoverParameters->CabNo!=0) //i ma kogoś w kabinie
if (Track->Event0) //a jest w tym torze event od stania
RaAxleEvent(Track->Event0); //dodanie eventu stania do kolejki
*/
vFloor=vector3(0,0,MoverParameters->Floor); //wektor podłogi dla wagonów, przesuwa ładunek
return MoverParameters->Dim.L; //długość większa od zera oznacza OK; 2mm docisku?
}
void __fastcall TDynamicObject::FastMove(double fDistance)
{
MoverParameters->dMoveLen=MoverParameters->dMoveLen+fDistance;
}
void __fastcall TDynamicObject::Move(double fDistance)
{//przesuwanie pojazdu po trajektorii polega na przesuwaniu poszczególnych osi
//Ra: wartość prędkości 2km/h ma ograniczyć aktywację eventów w przypadku drgań
if (Axle0.GetTrack()==Axle1.GetTrack()) //przed przesunięciem
{//powiązanie pojazdu z osią można zmienić tylko wtedy, gdy skrajne osie są na tym samym torze
if (MoverParameters->Vel>2) //|[km/h]| nie ma sensu zmiana osi, jesli pojazd drga na postoju
iAxleFirst=(MoverParameters->V>=0.0)?1:0; //[m/s] ?1:0 - aktywna druga oś w kierunku jazdy
//aktualnie eventy aktywuje druga oś, żeby AI nie wyłączało sobie semafora za szybko
}
if (fDistance>0.0)
{//gdy ruch w stronę sprzęgu 0, doliczyć korektę do osi 1
bEnabled&=Axle0.Move(fDistance,!iAxleFirst); //oś z przodu pojazdu
bEnabled&=Axle1.Move(fDistance/*-fAdjustment*/,iAxleFirst); //oś z tyłu pojazdu
}
else if (fDistance<0.0)
{//gdy ruch w stronę sprzęgu 1, doliczyć korektę do osi 0
bEnabled&=Axle1.Move(fDistance,iAxleFirst); //oś z tyłu pojazdu prusza się pierwsza
bEnabled&=Axle0.Move(fDistance/*-fAdjustment*/,!iAxleFirst); //oś z przodu pojazdu
}
//Axle2.Move(fDistance,false); //te nigdy pierwsze nie są
//Axle3.Move(fDistance,false);
if (fDistance!=0.0) //nie liczyć ponownie, jeśli stoi
{//liczenie pozycji pojazdu tutaj, bo jest używane w wielu miejscach
vPosition=0.5*(Axle1.pPosition+Axle0.pPosition); //środek między skrajnymi osiami
vFront=Axle0.pPosition-Axle1.pPosition; //wektor pomiędzy skrajnymi osiami
//Ra 2F1J: to nie jest stabilne (powoduje rzucanie taborem) i wymaga dopracowania
fAdjustment=vFront.Length()-fAxleDist; //na łuku będzie ujemny
//if (fabs(fAdjustment)>0.02) //jeśli jest zbyt dużo, to rozłożyć na kilka przeliczeń (wygasza drgania?)
//{//parę centymetrów trzeba by już skorygować; te błędy mogą się też generować na ostrych łukach
// fAdjustment*=0.5; //w jednym kroku korygowany jest ułamek błędu
//}
//else
// fAdjustment=0.0;
vFront=Normalize(vFront); //kierunek ustawienia pojazdu (wektor jednostkowy)
vLeft=Normalize(CrossProduct(vWorldUp,vFront)); //wektor poziomy w lewo, normalizacja potrzebna z powodu pochylenia (vFront)
vUp=CrossProduct(vFront,vLeft); //wektor w górę, będzie jednostkowy
modelRot.z=atan2(-vFront.x,vFront.z); //kąt obrotu pojazdu [rad]; z ABuBogies()
double a=((Axle1.GetRoll()+Axle0.GetRoll())); //suma przechyłek
if (a!=0.0)
{//wyznaczanie przechylenia tylko jeśli jest przechyłka
//można by pobrać wektory normalne z toru...
mMatrix.Identity(); //ta macierz jest potrzebna głównie do wyświetlania
mMatrix.Rotation(a*0.5,vFront); //obrót wzdłuż osi o przechyłkę
vUp=mMatrix*vUp; //wektor w górę pojazdu (przekręcenie na przechyłce)
//vLeft=mMatrix*DynamicObject->vLeft;
//vUp=CrossProduct(vFront,vLeft); //wektor w górę
//vLeft=Normalize(CrossProduct(vWorldUp,vFront)); //wektor w lewo
vLeft=Normalize(CrossProduct(vUp,vFront)); //wektor w lewo
//vUp=CrossProduct(vFront,vLeft); //wektor w górę
}
mMatrix.Identity(); //to też można by od razu policzyć, ale potrzebne jest do wyświetlania
mMatrix.BasisChange(vLeft,vUp,vFront); //przesuwanie jest jednak rzadziej niż renderowanie
mMatrix=Inverse(mMatrix); //wyliczenie macierzy dla pojazdu (potrzebna tylko do wyświetlania?)
//if (MoverParameters->CategoryFlag&2)
{//przesunięcia są używane po wyrzuceniu pociągu z toru
vPosition.x+=MoverParameters->OffsetTrackH*vLeft.x; //dodanie przesunięcia w bok
vPosition.z+=MoverParameters->OffsetTrackH*vLeft.z; //vLeft jest wektorem poprzecznym
//if () na przechyłce będzie dodatkowo zmiana wysokości samochodu
vPosition.y+=MoverParameters->OffsetTrackV; //te offsety są liczone przez moverparam
}
//Ra: skopiowanie pozycji do fizyki, tam potrzebna do zrywania sprzęgów
//MoverParameters->Loc.X=-vPosition.x; //robi to {Fast}ComputeMovement()
//MoverParameters->Loc.Y= vPosition.z;
//MoverParameters->Loc.Z= vPosition.y;
//obliczanie pozycji sprzęgów do liczenia zderzeń
vector3 dir=(0.5*MoverParameters->Dim.L)*vFront; //wektor sprzęgu
vCoulpler[0]=vPosition+dir; //współrzędne sprzęgu na początku
vCoulpler[1]=vPosition-dir; //współrzędne sprzęgu na końcu
MoverParameters->vCoulpler[0]=vCoulpler[0]; //tymczasowo kopiowane na inny poziom
MoverParameters->vCoulpler[1]=vCoulpler[1];
//bCameraNear=
//if (bCameraNear) //jeśli istotne są szczegóły (blisko kamery)
{//przeliczenie cienia
TTrack *t0=Axle0.GetTrack(); //już po przesunięciu
TTrack *t1=Axle1.GetTrack();
if ((t0->eEnvironment==e_flat)&&(t1->eEnvironment==e_flat)) //może być e_bridge...
fShade=0.0; //standardowe oświetlenie
else
{//jeżeli te tory mają niestandardowy stopień zacienienia (e_canyon, e_tunnel)
if (t0->eEnvironment==t1->eEnvironment)
{switch (t0->eEnvironment)
{//typ zmiany oświetlenia
case e_canyon: fShade=0.65; break; //zacienienie w kanionie
case e_tunnel: fShade=0.20; break; //zacienienie w tunelu
}
}
else //dwa różne
{//liczymy proporcję
double d=Axle0.GetTranslation(); //aktualne położenie na torze
if (Axle0.GetDirection()<0)
d=t0->fTrackLength-d; //od drugiej strony liczona długość
d/=fAxleDist; //rozsataw osi procentowe znajdowanie się na torze
switch (t0->eEnvironment)
{//typ zmiany oświetlenia - zakładam, że drugi tor ma e_flat
case e_canyon: fShade=(d*0.65)+(1.0-d); break; //zacienienie w kanionie
case e_tunnel: fShade=(d*0.20)+(1.0-d); break; //zacienienie w tunelu
}
switch (t1->eEnvironment)
{//typ zmiany oświetlenia - zakładam, że pierwszy tor ma e_flat
case e_canyon: fShade=d+(1.0-d)*0.65; break; //zacienienie w kanionie
case e_tunnel: fShade=d+(1.0-d)*0.20; break; //zacienienie w tunelu
}
}
}
}
}
};
void __fastcall TDynamicObject::AttachPrev(TDynamicObject *Object, int iType)
{//Ra: doczepia Object na końcu składu (nazwa funkcji może być myląca)
//Ra: używane tylko przy wczytywaniu scenerii
/*
//Ra: po wstawieniu pojazdu do scenerii nie miał on ustawionej pozycji, teraz już ma
TLocation loc;
loc.X=-vPosition.x;
loc.Y=vPosition.z;
loc.Z=vPosition.y;
MoverParameters->Loc=loc; //Ra: do obliczania sprzęgów, na starcie nie są przesunięte
loc.X=-Object->vPosition.x;
loc.Y=Object->vPosition.z;
loc.Z=Object->vPosition.y;
Object->MoverParameters->Loc=loc; //ustawienie dodawanego pojazdu
*/
MoverParameters->Attach(iDirection,Object->iDirection^1,Object->MoverParameters,iType,true);
MoverParameters->Couplers[iDirection].Render=false;
Object->MoverParameters->Attach(Object->iDirection^1,iDirection,MoverParameters,iType,true);
Object->MoverParameters->Couplers[Object->iDirection^1].Render=true; //rysowanie sprzęgu w dołączanym
if (iDirection)
{//łączenie standardowe
NextConnected=Object; //normalnie doczepiamy go sobie do sprzęgu 1
NextConnectedNo=Object->iDirection^1;
}
else
{//łączenie odwrotne
PrevConnected=Object; //doczepiamy go sobie do sprzęgu 0, gdy stoimy odwrotnie
PrevConnectedNo=Object->iDirection^1;
}
if (Object->iDirection)
{//dołączany jest normalnie ustawiany
Object->PrevConnected=this; //on ma nas z przodu
Object->PrevConnectedNo=iDirection;
}
else
{//dołączany jest odwrotnie ustawiany
Object->NextConnected=this; //on ma nas z tyłu
Object->NextConnectedNo=iDirection;
}
if (MoverParameters->TrainType&dt_EZT) //w przypadku łączenia członów, światła w rozrządczym zależą od stanu w silnikowym
if (MoverParameters->Couplers[iDirection].AllowedFlag&ctrain_depot) //gdy sprzęgi łączone warsztatowo (powiedzmy)
if ((MoverParameters->Power<1.0)&&(Object->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma
iLights=Object->MoverParameters->iLights; //to w tym z mocą będą światła załączane, a w tym bez tylko widoczne
else if ((MoverParameters->Power>1.0)&&(Object->MoverParameters->Power<1.0)) //my mamy moc, ale ten drugi nie ma
Object->iLights=MoverParameters->iLights; //to w tym z mocą będą światła załączane, a w tym bez tylko widoczne
return;
//SetPneumatic(1,1); //Ra: to i tak się nie wykonywało po return
//SetPneumatic(1,0);
//SetPneumatic(0,1);
//SetPneumatic(0,0);
}
bool __fastcall TDynamicObject::UpdateForce(double dt, double dt1, bool FullVer)
{
if (!bEnabled)
return false;
if (dt>0)
MoverParameters->ComputeTotalForce(dt,dt1,FullVer); //wywalenie WS zależy od ustawienia kierunku
return true;
}
void __fastcall TDynamicObject::LoadUpdate()
{//przeładowanie modelu ładunku
// Ra: nie próbujemy wczytywać modeli miliony razy podczas renderowania!!!
if ((mdLoad==NULL)&&(MoverParameters->Load>0))
{
AnsiString asLoadName=asBaseDir+MoverParameters->LoadType+".t3d"; //zapamiętany katalog pojazdu
//asLoadName=MoverParameters->LoadType;
//if (MoverParameters->LoadType!=AnsiString("passengers"))
Global::asCurrentTexturePath=asBaseDir; //bieżąca ścieżka do tekstur to dynamic/...
mdLoad=TModelsManager::GetModel(asLoadName.c_str()); //nowy ładunek
Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur
//Ra: w MMD można by zapisać położenie modelu ładunku (np. węgiel) w zależności od załadowania
}
else if (MoverParameters->Load==0)
mdLoad=NULL; //nie ma ładunku
//if ((mdLoad==NULL)&&(MoverParameters->Load>0))
// {
// mdLoad=NULL; //Ra: to jest tu bez sensu - co autor miał na myśli?
// }
MoverParameters->LoadStatus&=3; //po zakończeniu będzie równe zero
};
/*
double __fastcall ComputeRadius(double p1x, double p1z, double p2x, double p2z,
double p3x, double p3z, double p4x, double p4z)
{
double v1z= p1x-p2x;
double v1x= p1z-p2z;
double v4z= p3x-p4x;
double v4x= p3z-p4z;
double A1= p2z-p1z;
double B1= p1x-p2x;
double C1= -p1z*B1-p1x*A1;
double A2= p4z-p3z;
double B2= p3x-p4x;
double C2= -p3z*B1-p3x*A1;
double y= (A1*C2/A2-C1)/(B1-A1*B2/A2);
double x= (-B2*y-C2)/A2;
}
*/
double __fastcall TDynamicObject::ComputeRadius(vector3 p1, vector3 p2, vector3 p3, vector3 p4)
{
// vector3 v1
// TLine l1= TLine(p1,p1-p2);
// TLine l4= TLine(p4,p4-p3);
// TPlane p1= l1.GetPlane();
// vector3 pt;
// CrossPoint(pt,l4,p1);
double R= 0.0;
vector3 p12= p1-p2;
vector3 p34= p3-p4;
p12= CrossProduct(p12,vector3(0.0,0.1,0.0));
p12=Normalize(p12);
p34= CrossProduct(p34,vector3(0.0,0.1,0.0));
p34=Normalize(p34);
if (fabs(p1.x-p2.x)>0.01)
{
if (fabs(p12.x-p34.x)>0.001)
R=(p1.x-p4.x)/(p34.x-p12.x);
}
else
{
if (fabs(p12.z-p34.z)>0.001)
R=(p1.z-p4.z)/(p34.z-p12.z);
}
return(R);
}
/*
double __fastcall TDynamicObject::ComputeRadius()
{
double L=0;
double d=0;
d=sqrt(SquareMagnitude(Axle0.pPosition-Axle1.pPosition));
L=Axle1.GetLength(Axle1.pPosition,Axle1.pPosition-Axle2.pPosition,Axle0.pPosition-Axle3.pPosition,Axle0.pPosition);
double eps=0.01;
double R= 0;
double L_d;
if ((L>0) || (d>0))
{
L_d= L-d;
if (L_d>eps)
{
R=L*sqrt(L/(24*(L_d)));
}
}
return R;
}
*/
/* Ra: na razie nie potrzebne
void __fastcall TDynamicObject::UpdatePos()
{
MoverParameters->Loc.X= -vPosition.x;
MoverParameters->Loc.Y= vPosition.z;
MoverParameters->Loc.Z= vPosition.y;
}
*/
/*
Ra:
Powinny być dwie funkcje wykonujące aktualizację fizyki. Jedna wykonująca
krok obliczeń, powtarzana odpowiednią liczbę razy, a druga wykonująca zbiorczą
aktualzację mniej istotnych elementów.
Ponadto należało by ustalić odległość składów od kamery i jeśli przekracza
ona np. 10km, to traktować składy jako uproszczone, np. bez wnikania w siły
na sprzęgach, opóźnienie działania hamulca itp. Oczywiście musi mieć to pewną
histerezę czasową, aby te tryby pracy nie przełączały się zbyt szybko.
*/
bool __fastcall TDynamicObject::Update(double dt, double dt1)
{
if (dt==0) return true; //Ra: pauza
if (!MoverParameters->PhysicActivation&&!MechInside) //to drugie, bo będąc w maszynowym blokuje się fizyka
return true; //McZapkie: wylaczanie fizyki gdy nie potrzeba
if (!MyTrack)
return false; //pojazdy postawione na torach portalowych mają MyTrack==NULL
if (!bEnabled)
return false; //a normalnie powinny mieć bEnabled==false
//Ra: przeniosłem - no już lepiej tu, niż w wyświetlaniu!
//if ((MoverParameters->ConverterFlag==false) && (MoverParameters->TrainType!=dt_ET22))
//Ra: to nie może tu być, bo wyłącza sprężarkę w rozrządczym EZT!
//if ((MoverParameters->ConverterFlag==false)&&(MoverParameters->CompressorPower!=0))
// MoverParameters->CompressorFlag=false;
//if (MoverParameters->CompressorPower==2)
// MoverParameters->CompressorAllow=MoverParameters->ConverterFlag;
//McZapkie-260202
if ((MoverParameters->EnginePowerSource.SourceType==CurrentCollector)&&(MoverParameters->Power>1.0)) //aby rozrządczy nie opuszczał silnikowemu
if ((MechInside)||(MoverParameters->TrainType==dt_EZT))
{
//if ((!MoverParameters->PantCompFlag)&&(MoverParameters->CompressedVolume>=2.8))
// MoverParameters->PantVolume=MoverParameters->CompressedVolume;
if (MoverParameters->PantPress<(MoverParameters->TrainType==dt_EZT?2.4:3.5))
{// 3.5 wg http://www.transportszynowy.pl/eu06-07pneumat.php
//"Wyłączniki ciśnieniowe odbieraków prądu wyłączają sterowanie wyłącznika szybkiego oraz uniemożliwiają podniesienie odbieraków prądu, gdy w instalacji rozrządu ciśnienie spadnie poniżej wartości 3,5 bara."
//Ra 2013-12: Niebugocław mówi, że w EZT podnoszą się przy 2.5
//if (!MoverParameters->PantCompFlag)
// MoverParameters->PantVolume=MoverParameters->CompressedVolume;
MoverParameters->PantFront(false); //opuszczenie pantografów przy niskim ciśnieniu
MoverParameters->PantRear(false); //to idzie w ukrotnieniu, a nie powinno...
}
//Winger - automatyczne wylaczanie malej sprezarki
else if (MoverParameters->PantPress>=4.8)
MoverParameters->PantCompFlag=false;
} //Ra: do Mover to trzeba przenieść, żeby AI też mogło sobie podpompować
double dDOMoveLen;
TLocation l;
l.X=-vPosition.x; //przekazanie pozycji do fizyki
l.Y=vPosition.z;
l.Z=vPosition.y;
TRotation r;
r.Rx=r.Ry=r.Rz=0;
//McZapkie: parametry powinny byc pobierane z toru
//TTrackShape ts;
//ts.R=MyTrack->fRadius;
//if (ABuGetDirection()<0) ts.R=-ts.R;
// ts.R=MyTrack->fRadius; //ujemne promienie są już zamienione przy wczytywaniu
if (Axle0.vAngles.z!=Axle1.vAngles.z)
{//wyliczenie promienia z obrotów osi - modyfikację zgłosił youBy
ts.R=Axle0.vAngles.z-Axle1.vAngles.z; //różnica może dawać stałą ±M_2PI
if (ts.R>M_PI) ts.R-=M_2PI else if (ts.R<-M_PI) ts.R+=M_2PI; //normalizacja
// ts.R=fabs(0.5*MoverParameters->BDist/sin(ts.R*0.5));
ts.R=-0.5*MoverParameters->BDist/sin(ts.R*0.5);
if ((ts.R>15000.0)||(ts.R<-15000.0)) ts.R=0.0; //szkoda czasu na zbyt duże promienie, 4km to promień nie wymagający przechyłki
}
else ts.R=0.0;
//ts.R=ComputeRadius(Axle1.pPosition,Axle2.pPosition,Axle3.pPosition,Axle0.pPosition);
//Ra: składową pochylenia wzdłużnego mamy policzoną w jednostkowym wektorze vFront
ts.Len=1.0; //Max0R(MoverParameters->BDist,MoverParameters->ADist);
ts.dHtrack=-vFront.y; //Axle1.pPosition.y-Axle0.pPosition.y; //wektor między skrajnymi osiami (!!!odwrotny)
ts.dHrail=(Axle1.GetRoll()+Axle0.GetRoll())*0.5; //średnia przechyłka pudła
//TTrackParam tp;
tp.Width=MyTrack->fTrackWidth;
//McZapkie-250202
tp.friction=MyTrack->fFriction*Global::fFriction;
tp.CategoryFlag=MyTrack->iCategoryFlag&15;
tp.DamageFlag=MyTrack->iDamageFlag;
tp.QualityFlag=MyTrack->iQualityFlag;
if ((MoverParameters->Couplers[0].CouplingFlag>0)
&&(MoverParameters->Couplers[1].CouplingFlag>0))
{
MoverParameters->InsideConsist=true;
}
else
{
MoverParameters->InsideConsist=false;
}
//napiecie sieci trakcyjnej
//Ra 15-01: przeliczenie poboru prądu powinno być robione wcześniej, żeby na tym etapie były znane napięcia
//TTractionParam tmpTraction;
//tmpTraction.TractionVoltage=0;
if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector)
{//dla EZT tylko silnikowy
//if (Global::bLiveTraction)
{//Ra 2013-12: to niżej jest chyba trochę bez sensu
double v=MoverParameters->PantRearVolt;
if (v==0.0)
{v=MoverParameters->PantFrontVolt;
if (v==0.0)
if (MoverParameters->TrainType&(dt_EZT|dt_ET40|dt_ET41|dt_ET42)) //dwuczłony mogą mieć sprzęg WN
v=MoverParameters->GetTrainsetVoltage(); //ostatnia szansa
}
if (v!=0.0)
{//jeśli jest zasilanie
NoVoltTime=0;
tmpTraction.TractionVoltage=v;
}
else
{
/*
if (MoverParameters->Vel>0.1f) //jeśli jedzie
if (NoVoltTime==0.0) //tylko przy pierwszym zaniku napięcia
if (MoverParameters->PantFrontUp||MoverParameters->PantRearUp)
//if ((pants[0].fParamPants->PantTraction>1.0)||(pants[1].fParamPants->PantTraction>1.0))
{//wspomagacz usuwania problemów z siecią
if (!Global::iPause)
{//Ra: tymczasowa teleportacja do miejsca, gdzie brakuje prądu
Global::SetCameraPosition(vPosition+vector3(0,0,5)); //nowa pozycja dla generowania obiektów
Global::pCamera->Init(vPosition+vector3(0,0,5),Global::pFreeCameraInitAngle[0]); //przestawienie
}
Global:l::pGround->Silence(Global::pCamera->Pos); //wyciszenie wszystkiego z poprzedniej pozycji
Globa:iPause|=1; //tymczasowe zapauzowanie, gdy problem z siecią
}
*/
NoVoltTime=NoVoltTime+dt;
if (NoVoltTime>0.2) //jeśli brak zasilania dłużej niż 0.2 sekundy (25km/h pod izolatorem daje 0.15s)
{//Ra 2F1H: prowizorka, trzeba przechować napięcie, żeby nie wywalało WS pod izolatorem
if (MoverParameters->Vel>0.5) //jeśli jedzie
if (MoverParameters->PantFrontUp||MoverParameters->PantRearUp) //Ra 2014-07: doraźna blokada logowania zimnych lokomotyw - zrobić to trzeba inaczej
//if (NoVoltTime>0.02) //tu można ograniczyć czas rozłączenia
//if (DebugModeFlag) //logowanie nie zawsze
if (MoverParameters->Mains)
{//Ra 15-01: logować tylko, jeśli WS załączony
//if (MoverParameters->PantFrontUp&&pants)
//Ra 15-01: bezwzględne współrzędne pantografu nie są dostępne, więc lepiej się tego nie zaloguje
ErrorLog("Voltage loss: by "+MoverParameters->Name+" at "+FloatToStrF(vPosition.x,ffFixed,7,2)+" "+FloatToStrF(vPosition.y,ffFixed,7,2)+" "+FloatToStrF(vPosition.z,ffFixed,7,2)+", time "+FloatToStrF(NoVoltTime,ffFixed,7,2));
//if (MoverParameters->PantRearUp)
// if (iAnimType[ANIM_PANTS]>1)
// if (pants[1])
// ErrorLog("Voltage loss: by "+MoverParameters->Name+" at "+FloatToStrF(vPosition.x,ffFixed,7,2)+" "+FloatToStrF(vPosition.y,ffFixed,7,2)+" "+FloatToStrF(vPosition.z,ffFixed,7,2)+", time "+FloatToStrF(NoVoltTime,ffFixed,7,2));
}
//Ra 2F1H: nie było sensu wpisywać tu zera po upływie czasu, bo zmienna była tymczasowa, a napięcie zerowane od razu
tmpTraction.TractionVoltage=0; //Ra 2013-12: po co tak?
//pControlled->MainSwitch(false); //może tak?
}
}
}
//else //Ra: nie no, trzeba podnieść pantografy, jak nie będzie drutu, to będą miały prąd po osiągnięciu 1.4m
// tmpTraction.TractionVoltage=0.95*MoverParameters->EnginePowerSource.MaxVoltage;
}
else
tmpTraction.TractionVoltage=0.95*MoverParameters->EnginePowerSource.MaxVoltage;
tmpTraction.TractionFreq=0;
tmpTraction.TractionMaxCurrent=7500; //Ra: chyba za dużo? powinno wywalać przy 1500
tmpTraction.TractionResistivity=0.3;
//McZapkie: predkosc w torze przekazac do TrackParam
//McZapkie: Vel ma wymiar [km/h] (absolutny), V ma wymiar [m/s], taka przyjalem notacje
tp.Velmax=MyTrack->VelocityGet();
if (Mechanik)
{//Ra 2F3F: do Driver.cpp to przenieść?
MoverParameters->EqvtPipePress=GetEPP(); //srednie cisnienie w PG
if ((Mechanik->Primary())&&(MoverParameters->EngineType==ElectricInductionMotor)) //jesli glowny i z asynchronami, to niech steruje
{ //hamulcem lacznie dla calego pociagu/ezt
//1. ustal wymagana sile hamowania calego pociagu
// - opoznienie moze byc ustalane na podstawie charakterystyki
// - opoznienie moze byc ustalane na podstawie mas i cisnien granicznych
//
//2. ustal mozliwa do realizacji sile hamowania ED
// - w szczegolnosci powinien brac pod uwage rozne sily hamowania
float FED=0;
// for(TDynamicObject *p=GetFirstDynamic(4);p;p->NextC(4))
// FED+=p->MoverParameters->eimv[eimv_Fmax];
//3. ustaw pojazdom sile hamowania ED
// - proporcjonalnie do mozliwosci
//4. ustal potrzebne dohamowanie pneumatyczne
// - od sily zadanej trzeba odjac realizowana przez ED
//5. w razie potrzeby wlacz hamulec utrzymujacy
// - gdy zahamowany ma ponizej 2 km/h
//6. ustaw pojazdom sile hamowania ep
// - proporcjonalnie do masy, do liczby osi, rowne cisnienia - jak bedzie, tak bedzie dobrze
}
//yB: cos (AI) tu jest nie kompatybilne z czyms (hamulce)
// if (Controller!=Humandriver)
// if (Mechanik->LastReactionTime>0.5)
// {
// MoverParameters->BrakeCtrlPos=0;
// Mechanik->LastReactionTime=0;
// }
Mechanik->UpdateSituation(dt1); //przebłyski świadomości AI
}
//fragment "z EXE Kursa"
if (MoverParameters->Mains) //nie wchodzić w funkcję bez potrzeby
if ((!MoverParameters->Battery)&&(Controller==Humandriver)&&(MoverParameters->EngineType!=DieselEngine)&&(MoverParameters->EngineType!=WheelsDriven))
{//jeśli bateria wyłączona, a nie diesel ani drezyna reczna
if (MoverParameters->MainSwitch(false)) //wyłączyć zasilanie
MoverParameters->EventFlag=true;
}
if (MoverParameters->TrainType==dt_ET42)
{//powinny być wszystkie dwuczłony oraz EZT
/*
//Ra: to jest bez sensu, bo wyłącza WS przy przechodzeniu przez "wewnętrzne" kabiny (z powodu ActiveCab)
//trzeba to zrobić inaczej, np. dla członu A sprawdzać, czy jest B
//albo sprawdzać w momencie załączania WS i zmiany w sprzęgach
if (((TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab>0)&&(NextConnected->MoverParameters->TrainType!=dt_ET42))||((TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab<0)&&(PrevConnected->MoverParameters->TrainType!=dt_ET42)))
{//sprawdzenie, czy z tyłu kabiny mamy drugi człon
if (MoverParameters->MainSwitch(false))
MoverParameters->EventFlag=true;
}
if ((!(TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab>0))||(!(TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab<0)))
{
if (MoverParameters->MainSwitch(false))
MoverParameters->EventFlag=true;
}
*/
}
//McZapkie-260202 - dMoveLen przyda sie przy stukocie kol
dDOMoveLen=GetdMoveLen()+MoverParameters->ComputeMovement(dt,dt1,ts,tp,tmpTraction,l,r);
//yB: zeby zawsze wrzucalo w jedna strone zakretu
MoverParameters->AccN*=-ABuGetDirection();
//if (dDOMoveLen!=0.0) //Ra: nie może być, bo blokuje Event0
Move(dDOMoveLen);
if (!bEnabled) //usuwane pojazdy nie mają toru
{//pojazd do usunięcia
Global::pGround->bDynamicRemove=true; //sprawdzić
return false;
}
Global::ABuDebug=dDOMoveLen/dt1;
ResetdMoveLen();
//McZapkie-260202
//tupot mew, tfu, stukot kol:
DWORD stat;
//taka prowizorka zeby sciszyc stukot dalekiej lokomotywy
double ObjectDist;
double vol=0;
//double freq; //Ra: nie używane
ObjectDist=SquareMagnitude(Global::pCameraPosition-vPosition);
//McZapkie-270202
if (MyTrack->fSoundDistance!=-1)
{
if (ObjectDist<rsStukot[0].dSoundAtt*rsStukot[0].dSoundAtt*15.0)
{
vol= (20.0+MyTrack->iDamageFlag)/21;
if (MyTrack->eEnvironment==e_tunnel)
{
vol*=1.1;
//freq=1.02;
}
else
if (MyTrack->eEnvironment==e_bridge)
{
vol*=1.2;
//freq=0.99; //MC: stukot w zaleznosci od tego gdzie jest tor
}
if (MyTrack->fSoundDistance!=dRailLength)
{
dRailLength=MyTrack->fSoundDistance;
for (int i=0; i<iAxles; i++)
{
dRailPosition[i]=dWheelsPosition[i]+MoverParameters->Dim.L;
}
}
if (dRailLength!=-1)
{
if (abs(MoverParameters->V)>0)
{
for (int i=0; i<iAxles; i++)
{
dRailPosition[i]-=dDOMoveLen*Sign(dDOMoveLen);
if (dRailPosition[i]<0)
{
//McZapkie-040302
if (i==iAxles-1)
{
rsStukot[0].Stop();
MoverParameters->AccV+= 0.5*GetVelocity()/(1+MoverParameters->Vmax);
}
else
{rsStukot[i+1].Stop();}
rsStukot[i].Play(vol,0,MechInside,vPosition); //poprawic pozycje o uklad osi
if (i==1)
MoverParameters->AccV-= 0.5*GetVelocity()/(1+MoverParameters->Vmax);
dRailPosition[i]+=dRailLength;
}
}
}
}
}
}
//McZapkie-260202 end
//yB: przyspieszacz (moze zadziala, ale dzwiek juz jest)
int flag=MoverParameters->Hamulec->GetSoundFlag();
if ((bBrakeAcc)&&(TestFlag(flag,sf_Acc))&&(ObjectDist<2500))
{
sBrakeAcc->SetVolume(-ObjectDist*3-(FreeFlyModeFlag?0:2000));
sBrakeAcc->Play(0,0,0);
sBrakeAcc->SetPan(10000*sin(ModCamRot));
}
if ((rsUnbrake.AM!=0)&&(ObjectDist<5000))
{
if ((TestFlag(flag,sf_CylU)) && ((MoverParameters->BrakePress*MoverParameters->MaxBrakePress[3])>0.05))
{
vol=Min0R(0.2+1.6*sqrt((MoverParameters->BrakePress>0?MoverParameters->BrakePress:0)/MoverParameters->MaxBrakePress[3]),1);
vol=vol+(FreeFlyModeFlag?0:-0.5)-ObjectDist/5000;
rsUnbrake.SetPan(10000*sin(ModCamRot));
rsUnbrake.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition());
}
else
rsUnbrake.Stop();
}
//fragment z EXE Kursa
/* if (MoverParameters->TrainType==dt_ET42)
{
if ((MoverParameters->DynamicBrakeType=dbrake_switch) && ((MoverParameters->BrakePress > 0.2) || ( MoverParameters->PipePress < 0.36 )))
{
MoverParameters->StLinFlag=true;
}
else
if ((MoverParameters->DynamicBrakeType=dbrake_switch) && (MoverParameters->BrakePress < 0.1))
{
MoverParameters->StLinFlag=false;
}
} */
if ((MoverParameters->TrainType==dt_ET40) || (MoverParameters->TrainType==dt_EP05))
{//dla ET40 i EU05 automatyczne cofanie nastawnika - i tak nie będzie to działać dobrze...
/* if ((MoverParameters->MainCtrlPos>MoverParameters->MainCtrlActualPos)&&(abs(MoverParameters->Im)>MoverParameters->IminHi))
{
MoverParameters->DecMainCtrl(1);
} */
if (( !Console::Pressed(Global::Keys[k_IncMainCtrl]))&&(MoverParameters->MainCtrlPos>MoverParameters->MainCtrlActualPos))
{
MoverParameters->DecMainCtrl(1);
}
if (( !Console::Pressed(Global::Keys[k_DecMainCtrl]))&&(MoverParameters->MainCtrlPos<MoverParameters->MainCtrlActualPos))
{
MoverParameters->IncMainCtrl(1); //Ra 15-01: a to nie miało być tylko cofanie?
}
}
if (MoverParameters->Vel!=0)
{//McZapkie-050402: krecenie kolami:
dWheelAngle[0]+=114.59155902616464175359630962821*MoverParameters->V*dt1/MoverParameters->WheelDiameterL; //przednie toczne
dWheelAngle[1]+=MoverParameters->nrot*dt1*360.0; //napędne
dWheelAngle[2]+=114.59155902616464175359630962821*MoverParameters->V*dt1/MoverParameters->WheelDiameterT; //tylne toczne
if (dWheelAngle[0]>360.0) dWheelAngle[0]-=360.0; //a w drugą stronę jak się kręcą?
if (dWheelAngle[1]>360.0) dWheelAngle[1]-=360.0;
if (dWheelAngle[2]>360.0) dWheelAngle[2]-=360.0;
}
if (pants) //pantograf może być w wagonie kuchennym albo pojeździe rewizyjnym (np. SR61)
{//przeliczanie kątów dla pantografów
double k; //tymczasowy kąt
double PantDiff;
TAnimPant *p; //wskaźnik do obiektu danych pantografu
double fCurrent=(MoverParameters->DynamicBrakeFlag&&MoverParameters->ResistorsFlag?0:fabs(MoverParameters->Itot))+MoverParameters->TotalCurrent; //prąd pobierany przez pojazd - bez sensu z tym (TotalCurrent)
//fCurrent+=fabs(MoverParameters->Voltage)*1e-6; //prąd płynący przez woltomierz, rozładowuje kondensator orgromowy 4µF
double fPantCurrent=fCurrent; //normalnie cały prąd przez jeden pantograf
if (pants)
if (iAnimType[ANIM_PANTS]>1) //a jeśli są dwa pantografy //Ra 1014-11: proteza, trzeba zrobić sensowniej
if (pants[0].fParamPants->hvPowerWire&&pants[1].fParamPants->hvPowerWire) //i oba podłączone do drutów
fPantCurrent=fCurrent*0.5; //to dzielimy prąd równo na oba (trochę bez sensu, ale lepiej tak niż podwoić prąd)
for (int i=0;i<iAnimType[ANIM_PANTS];++i)
{//pętla po wszystkich pantografach
p=pants[i].fParamPants;
if (p->PantWys<0)
{//patograf został połamany, liczony nie będzie
if (p->fAngleL>p->fAngleL0)
p->fAngleL-=0.2*dt1; //nieco szybciej niż jak dla opuszczania
if (p->fAngleL<p->fAngleL0)
p->fAngleL=p->fAngleL0; //kąt graniczny
if (p->fAngleU<M_PI)
p->fAngleU+=0.5*dt1; //górne się musi ruszać szybciej.
if (p->fAngleU>M_PI)
p->fAngleU=M_PI;
if (i&1) //zgłoszono, że po połamaniu potrafi zostać zasilanie
MoverParameters->PantRearVolt=0.0;
else
MoverParameters->PantFrontVolt=0.0;
continue; //reszta wtedy nie jest wykonywana
}
PantDiff=p->PantTraction-p->PantWys; //docelowy-aktualny
switch (i) //numer pantografu
{//trzeba usunąć to rozróżnienie
case 0:
if (Global::bLiveTraction?false:!p->hvPowerWire) //jeśli nie ma drutu, może pooszukiwać
MoverParameters->PantFrontVolt=(p->PantWys>=1.2)?0.95*MoverParameters->EnginePowerSource.MaxVoltage:0.0;
else
if (MoverParameters->PantFrontUp?(PantDiff<0.01):false) //tolerancja niedolegania
{
if ((MoverParameters->PantFrontVolt==0.0)&&(MoverParameters->PantRearVolt==0.0))
sPantUp.Play(vol,0,MechInside,vPosition);
if (p->hvPowerWire) //TODO: wyliczyć trzeba prąd przypadający na pantograf i wstawić do GetVoltage()
{MoverParameters->PantFrontVolt=p->hvPowerWire->VoltageGet(MoverParameters->Voltage,fPantCurrent);
fCurrent-=fPantCurrent; //taki prąd płynie przez powyższy pantograf
}
else
MoverParameters->PantFrontVolt=0.0;
}
else
MoverParameters->PantFrontVolt=0.0;
break;
case 1:
if (Global::bLiveTraction?false:!p->hvPowerWire) //jeśli nie ma drutu, może pooszukiwać
MoverParameters->PantRearVolt=(p->PantWys>=1.2)?0.95*MoverParameters->EnginePowerSource.MaxVoltage:0.0;
else
if (MoverParameters->PantRearUp?(PantDiff<0.01):false)
{
if ((MoverParameters->PantRearVolt==0.0)&&(MoverParameters->PantFrontVolt==0.0))
sPantUp.Play(vol,0,MechInside,vPosition);
if (p->hvPowerWire) //TODO: wyliczyć trzeba prąd przypadający na pantograf i wstawić do GetVoltage()
{MoverParameters->PantRearVolt=p->hvPowerWire->VoltageGet(MoverParameters->Voltage,fPantCurrent);
fCurrent-=fPantCurrent; //taki prąd płynie przez powyższy pantograf
}
else
MoverParameters->PantRearVolt=0.0;
}
else
MoverParameters->PantRearVolt=0.0;
break;
} //pozostałe na razie nie obsługiwane
if (MoverParameters->PantPress>(MoverParameters->TrainType==dt_EZT?2.5:3.3)) //Ra 2013-12: Niebugocław mówi, że w EZT podnoszą się przy 2.5
pantspeedfactor=0.015*(MoverParameters->PantPress)*dt1; //z EXE Kursa //Ra: wysokość zależy od ciśnienia !!!
else
pantspeedfactor=0.0;
if (pantspeedfactor<0) pantspeedfactor=0;
k=p->fAngleL;
if (i?MoverParameters->PantRearUp:MoverParameters->PantFrontUp) //jeśli ma być podniesiony
{if (PantDiff>0.001) //jeśli nie dolega do drutu
{//jeśli poprzednia wysokość jest mniejsza niż pożądana, zwiększyć kąt dolnego ramienia zgodnie z ciśnieniem
if (pantspeedfactor>0.55*PantDiff) //0.55 to około pochodna kąta po wysokości
k+=0.55*PantDiff; //ograniczenie "skoku" w danej klatce
else
k+=pantspeedfactor; //dolne ramię
//jeśli przekroczono kąt graniczny, zablokować pantograf (wymaga interwencji pociągu sieciowego)
}
else if (PantDiff<-0.001)
{//drut się obniżył albo pantograf podniesiony za wysoko
//jeśli wysokość jest zbyt duża, wyznaczyć zmniejszenie kąta
//jeśli zmniejszenie kąta jest zbyt duże, przejść do trybu łamania pantografu
//if (PantFrontDiff<-0.05) //skok w dół o 5cm daje złąmanie pantografu
k+=0.4*PantDiff; //mniej niż pochodna kąta po wysokości
} //jeśli wysokość jest dobra, nic więcej nie liczyć
}
else
{//jeśli ma być na dole
if (k>p->fAngleL0) //jeśli wyżej niż położenie wyjściowe
k-=0.15*dt1; //ruch w dół
if (k<p->fAngleL0)
k=p->fAngleL0; //położenie minimalne
}
if (k!=p->fAngleL)
{//żeby nie liczyć w kilku miejscach ani gdy nie potrzeba
if (k+p->fAngleU<M_PI)
{//o ile nie został osiągnięty kąt maksymalny
p->fAngleL=k; //zmieniony kąt
//wyliczyć kąt górnego ramienia z wzoru (a)cosinusowego
//=acos((b*cos()+c)/a)
//p->dPantAngleT=acos((1.22*cos(k)+0.535)/1.755); //górne ramię
p->fAngleU=acos((p->fLenL1*cos(k)+p->fHoriz)/p->fLenU1); //górne ramię
//wyliczyć aktualną wysokość z wzoru sinusowego
//h=a*sin()+b*sin()
p->PantWys=p->fLenL1*sin(k)+p->fLenU1*sin(p->fAngleU)+p->fHeight; //wysokość całości
}
}
} //koniec pętli po pantografach
if ((MoverParameters->PantFrontSP==false)&&(MoverParameters->PantFrontUp==false))
{
sPantDown.Play(vol,0,MechInside,vPosition);
MoverParameters->PantFrontSP=true;
}
if ((MoverParameters->PantRearSP==false)&&(MoverParameters->PantRearUp==false))
{
sPantDown.Play(vol,0,MechInside,vPosition);
MoverParameters->PantRearSP=true;
}
if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector)
{//Winger 240404 - wylaczanie sprezarki i przetwornicy przy braku napiecia
if (tmpTraction.TractionVoltage==0)
{//to coś wyłączało dźwięk silnika w ST43!
MoverParameters->ConverterFlag=false;
MoverParameters->CompressorFlag=false; //Ra: to jest wątpliwe - wyłączenie sprężarki powinno być w jednym miejscu!
}
}
}
else if (MoverParameters->EnginePowerSource.SourceType==InternalSource)
if (MoverParameters->EnginePowerSource.PowerType==SteamPower)
//if (smPatykird1[0])
{//Ra: animacja rozrządu parowozu, na razie nieoptymalizowane
/* //Ra: tymczasowo wyłączone ze względu na porządkowanie animacji pantografów
double fi,dx,c2,ka,kc;
double sin_fi,cos_fi;
double L1=1.6688888888888889;
double L2=5.6666666666666667; //2550/450
double Lc=0.4;
double L=5.686422222; //2558.89/450
double G1,G2,G3,ksi,sin_ksi,gam;
double G1_2,G2_2,G3_2; //kwadraty
//ruch tłoków oraz korbowodów
for (int i=0;i<=1;++i)
{//obie strony w ten sam sposób
fi=DegToRad(dWheelAngle[1]+(i?pant2x:pant1x)); //kąt obrotu koła dla tłoka 1
sin_fi=sin(fi);
cos_fi=cos(fi);
dx=panty*cos_fi+sqrt(panth*panth-panty*panty*sin_fi*sin_fi)-panth; //nieoptymalne
if (smPatykird1[i]) //na razie zabezpieczenie
smPatykird1[i]->SetTranslate(float3(dx,0,0));
ka=-asin(panty/panth)*sin_fi;
if (smPatykirg1[i]) //na razie zabezpieczenie
smPatykirg1[i]->SetRotateXYZ(vector3(RadToDeg(ka),0,0));
//smPatykirg1[0]->SetRotate(float3(0,1,0),RadToDeg(fi)); //obracamy
//ruch drążka mimośrodkowego oraz jarzma
//korzystałem z pliku PDF "mm.pdf" (opis czworoboku korbowo-wahaczowego):
//"MECHANIKA MASZYN. Szkic wykładu i laboratorium komputerowego."
//Prof. dr hab. inż. Jerzy Zajączkowski, 2007, Politechnika Łódzka
//L1 - wysokość (w pionie) osi jarzma ponad osią koła
//L2 - odległość w poziomie osi jarzma od osi koła
//Lc - długość korby mimośrodu na kole
//Lr - promień jarzma =1.0 (pozostałe przeliczone proporcjonalnie)
//L - długość drążka mimośrodowego
//fi - kąt obrotu koła
//ksi - kąt obrotu jarzma (od pionu)
//gam - odchylenie drążka mimośrodowego od poziomu
//G1=(Lr*Lr+L1*L1+L2*L2+Kc*Lc-L*L-2.0*Lc*L2*cos(fi)+2.0*Lc*L1*sin(fi))/(Lr*Lr);
//G2=2.0*(L2-Lc*cos(fi))/Lr;
//G3=2.0*(L1-Lc*sin(fi))/Lr;
fi=DegToRad(dWheelAngle[1]+(i?pant2x:pant1x)-96.77416667); //kąt obrotu koła dla tłoka 1
//1) dla dWheelAngle[1]=0° korba jest w dół, a mimośród w stronę jarzma, czyli fi=-7°
//2) dla dWheelAngle[1]=90° korba jest do tyłu, a mimośród w dół, czyli fi=83°
sin_fi=sin(fi);
cos_fi=cos(fi);
G1=(1.0+L1*L1+L2*L2+Lc*Lc-L*L-2.0*Lc*L2*cos_fi+2.0*Lc*L1*sin_fi);
G1_2=G1*G1;
G2=2.0*(L2-Lc*cos_fi);
G2_2=G2*G2;
G3=2.0*(L1-Lc*sin_fi);
G3_2=G3*G3;
sin_ksi=(G1*G2-G3*_fm_sqrt(G2_2+G3_2-G1_2))/(G2_2+G3_2); //x1 (minus delta)
ksi=asin(sin_ksi); //kąt jarzma
if (smPatykirg2[i])
smPatykirg2[i]->SetRotateXYZ(vector3(RadToDeg(ksi),0,0)); //obrócenie jarzma
//1) ksi=-23°, gam=
//2) ksi=10°, gam=
//gam=acos((L2-sin_ksi-Lc*cos_fi)/L); //kąt od poziomu, liczony względem poziomu
//gam=asin((L1-cos_ksi-Lc*sin_fi)/L); //kąt od poziomu, liczony względem pionu
gam=atan2((L1-cos(ksi)+Lc*sin_fi),(L2-sin_ksi+Lc*cos_fi)); //kąt od poziomu
if (smPatykird2[i]) //na razie zabezpieczenie
smPatykird2[i]->SetRotateXYZ(vector3(RadToDeg(-gam-ksi),0,0)); //obrócenie drążka mimośrodowego
}
*/
}
//NBMX Obsluga drzwi, MC: zuniwersalnione
if ((dDoorMoveL<MoverParameters->DoorMaxShiftL) && (MoverParameters->DoorLeftOpened))
dDoorMoveL+=dt1*0.5*MoverParameters->DoorOpenSpeed;
if ((dDoorMoveL>0) && (!MoverParameters->DoorLeftOpened))
{
dDoorMoveL-=dt1*MoverParameters->DoorCloseSpeed;
if (dDoorMoveL<0)
dDoorMoveL=0;
}
if ((dDoorMoveR<MoverParameters->DoorMaxShiftR) && (MoverParameters->DoorRightOpened))
dDoorMoveR+=dt1*0.5*MoverParameters->DoorOpenSpeed;
if ((dDoorMoveR>0) && (!MoverParameters->DoorRightOpened))
{
dDoorMoveR-=dt1*MoverParameters->DoorCloseSpeed;
if (dDoorMoveR<0)
dDoorMoveR=0;
}
//ABu-160303 sledzenie toru przed obiektem: *******************************
//Z obserwacji: v>0 -> Coupler 0; v<0 ->coupler1 (Ra: prędkość jest związana z pojazdem)
//Rozroznienie jest tutaj, zeby niepotrzebnie nie skakac do funkcji. Nie jest uzaleznione
//od obecnosci AI, zeby uwzglednic np. jadace bez lokomotywy wagony.
//Ra: można by przenieść na poziom obiektu reprezentującego skład, aby nie sprawdzać środkowych
if (CouplCounter>25) //licznik, aby nie robić za każdym razem
{//poszukiwanie czegoś do zderzenia się
fTrackBlock=10000.0; //na razie nie ma przeszkód (na wypadek nie uruchomienia skanowania)
//jeśli nie ma zwrotnicy po drodze, to tylko przeliczyć odległość?
if (MoverParameters->V>0.03) //[m/s] jeśli jedzie do przodu (w kierunku Coupler 0)
{if (MoverParameters->Couplers[0].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego?
{ABuScanObjects(1,fScanDist); //szukanie czegoś do podłączenia
//WriteLog(asName+" - block 0: "+AnsiString(fTrackBlock));
}
}
else if (MoverParameters->V<-0.03) //[m/s] jeśli jedzie do tyłu (w kierunku Coupler 1)
if (MoverParameters->Couplers[1].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego?
{ABuScanObjects(-1,fScanDist);
//WriteLog(asName+" - block 1: "+AnsiString(fTrackBlock));
}
CouplCounter=random(20); //ponowne sprawdzenie po losowym czasie
}
if (MoverParameters->Vel>0.1) //[km/h]
++CouplCounter; //jazda sprzyja poszukiwaniu połączenia
else
{CouplCounter=25; //a bezruch nie, ale trzeba zaktualizować odległość, bo zawalidroga może sobie pojechać
}
if (MoverParameters->DerailReason>0)
{switch (MoverParameters->DerailReason)
{case 1: ErrorLog("Bad driving: "+asName+" derailed due to end of track"); break;
case 2: ErrorLog("Bad driving: "+asName+" derailed due to too high speed"); break;
case 3: ErrorLog("Bad dynamic: "+asName+" derailed due to track width"); break; //błąd w scenerii
case 4: ErrorLog("Bad dynamic: "+asName+" derailed due to wrong track type"); break; //błąd w scenerii
}
MoverParameters->DerailReason=0; //żeby tylko raz
}
if (MoverParameters->LoadStatus)
LoadUpdate(); //zmiana modelu ładunku
return true; //Ra: chyba tak?
}
bool __fastcall TDynamicObject::FastUpdate(double dt)
{
if (dt==0.0) return true; //Ra: pauza
double dDOMoveLen;
if (!MoverParameters->PhysicActivation)
return true; //McZapkie: wylaczanie fizyki gdy nie potrzeba
if (!bEnabled)
return false;
TLocation l;
l.X=-vPosition.x;
l.Y=vPosition.z;
l.Z=vPosition.y;
TRotation r;
r.Rx=r.Ry=r.Rz= 0;
//McZapkie: parametry powinny byc pobierane z toru
//ts.R=MyTrack->fRadius;
//ts.Len= Max0R(MoverParameters->BDist,MoverParameters->ADist);
//ts.dHtrack=Axle1.pPosition.y-Axle0.pPosition.y;
//ts.dHrail=((Axle1.GetRoll())+(Axle0.GetRoll()))*0.5f;
//tp.Width=MyTrack->fTrackWidth;
//McZapkie-250202
//tp.friction= MyTrack->fFriction;
//tp.CategoryFlag= MyTrack->iCategoryFlag&15;
//tp.DamageFlag=MyTrack->iDamageFlag;
//tp.QualityFlag=MyTrack->iQualityFlag;
dDOMoveLen=MoverParameters->FastComputeMovement(dt,ts,tp,l,r); // ,ts,tp,tmpTraction);
//Move(dDOMoveLen);
//ResetdMoveLen();
FastMove(dDOMoveLen);
if (MoverParameters->LoadStatus)
LoadUpdate(); //zmiana modelu ładunku
return true; //Ra: chyba tak?
}
//McZapkie-040402: liczenie pozycji uwzgledniajac wysokosc szyn itp.
//vector3 __fastcall TDynamicObject::GetPosition()
//{//Ra: pozycja pojazdu jest liczona zaraz po przesunięciu
// return vPosition;
//};
void __fastcall TDynamicObject::TurnOff()
{//wyłączenie rysowania submodeli zmiennych dla egemplarza pojazdu
btnOn=false;
btCoupler1.TurnOff();
btCoupler2.TurnOff();
btCPneumatic1.TurnOff();
btCPneumatic1r.TurnOff();
btCPneumatic2.TurnOff();
btCPneumatic2r.TurnOff();
btPneumatic1.TurnOff();
btPneumatic1r.TurnOff();
btPneumatic2.TurnOff();
btPneumatic2r.TurnOff();
btCCtrl1.TurnOff();
btCCtrl2.TurnOff();
btCPass1.TurnOff();
btCPass2.TurnOff();
btEndSignals11.TurnOff();
btEndSignals13.TurnOff();
btEndSignals21.TurnOff();
btEndSignals23.TurnOff();
btEndSignals1.TurnOff();
btEndSignals2.TurnOff();
btEndSignalsTab1.TurnOff();
btEndSignalsTab2.TurnOff();
btHeadSignals11.TurnOff();
btHeadSignals12.TurnOff();
btHeadSignals13.TurnOff();
btHeadSignals21.TurnOff();
btHeadSignals22.TurnOff();
btHeadSignals23.TurnOff();
};
void __fastcall TDynamicObject::Render()
{//rysowanie elementów nieprzezroczystych
//youBy - sprawdzamy, czy jest sens renderowac
double modelrotate;
vector3 tempangle;
// zmienne
renderme=false;
//przeklejka
double ObjSqrDist=SquareMagnitude(Global::pCameraPosition-vPosition);
//koniec przeklejki
if (ObjSqrDist<500) //jak jest blisko - do 70m
modelrotate=0.01; //mały kąt, żeby nie znikało
else
{//Global::pCameraRotation to kąt bewzględny w świecie (zero - na północ)
tempangle=(vPosition-Global::pCameraPosition); //wektor od kamery
modelrotate=ABuAcos(tempangle); //określenie kąta
//if (modelrotate>M_PI) modelrotate-=(2*M_PI);
modelrotate+=Global::pCameraRotation;
}
if (modelrotate>M_PI) modelrotate-=(2*M_PI);
if (modelrotate<-M_PI) modelrotate+=(2*M_PI);
ModCamRot=modelrotate;
modelrotate=abs(modelrotate);
if (modelrotate<maxrot) renderme=true;
if (renderme)
{
TSubModel::iInstance=(int)this; //żeby nie robić cudzych animacji
//AnsiString asLoadName="";
double ObjSqrDist=SquareMagnitude(Global::pCameraPosition-vPosition);
ABuLittleUpdate(ObjSqrDist); //ustawianie zmiennych submodeli dla wspólnego modelu
//Cone(vCoulpler[0],modelRot.z,0);
//Cone(vCoulpler[1],modelRot.z,1);
//ActualTrack= GetTrack(); //McZapkie-240702
#if RENDER_CONE
{//Ra: testowe renderowanie pozycji wózków w postaci ostrosłupów, wymaga GLUT32.DLL
double dir=RadToDeg(atan2(vLeft.z,vLeft.x));
Axle0.Render(0);
Axle1.Render(1); //bogieRot[0]
//if (PrevConnected) //renderowanie połączenia
}
#endif
glPushMatrix();
//vector3 pos= vPosition;
//double ObjDist= SquareMagnitude(Global::pCameraPosition-pos);
if (this==Global::pUserDynamic)
{//specjalne ustawienie, aby nie trzęsło
if (Global::bSmudge)
{//jak jest widoczna smuga, to pojazd renderować po wyrenderowaniu smugi
glPopMatrix(); //a to trzeba zebrać przed wyjściem
return;
}
//if (Global::pWorld->) //tu trzeba by ustawić animacje na modelu zewnętrznym
glLoadIdentity(); //zacząć od macierzy jedynkowej
Global::pCamera->SetCabMatrix(vPosition); //specjalne ustawienie kamery
}
else
glTranslated(vPosition.x,vPosition.y,vPosition.z); //standardowe przesunięcie względem początku scenerii
glMultMatrixd(mMatrix.getArray());
if (fShade>0.0)
{//Ra: zmiana oswietlenia w tunelu, wykopie
GLfloat ambientLight[4]= {0.5f,0.5f,0.5f,1.0f};
GLfloat diffuseLight[4]= {0.5f,0.5f,0.5f,1.0f};
GLfloat specularLight[4]={0.5f,0.5f,0.5f,1.0f};
//trochę problem z ambientem w wykopie...
for (int li=0;li<3;li++)
{
ambientLight[li]= Global::ambientDayLight[li]*fShade;
diffuseLight[li]= Global::diffuseDayLight[li]*fShade;
specularLight[li]=Global::specularDayLight[li]*fShade;
}
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);
}
if (Global::bUseVBO)
{//wersja VBO
if (mdLowPolyInt)
if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab)
mdLowPolyInt->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha);
mdModel->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdLoad) //renderowanie nieprzezroczystego ładunku
mdLoad->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdPrzedsionek)
mdPrzedsionek->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha);
}
else
{//wersja Display Lists
if (mdLowPolyInt)
if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab)
mdLowPolyInt->Render(ObjSqrDist,ReplacableSkinID,iAlpha);
mdModel->Render(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdLoad) //renderowanie nieprzezroczystego ładunku
mdLoad->Render(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdPrzedsionek)
mdPrzedsionek->Render(ObjSqrDist,ReplacableSkinID,iAlpha);
}
//Ra: czy ta kabina tu ma sens?
//Ra: czy nie renderuje się dwukrotnie?
//Ra: dlaczego jest zablokowana w przezroczystych?
if (mdKabina) //jeśli ma model kabiny
if ((mdKabina!=mdModel) && bDisplayCab && FreeFlyModeFlag)
{//rendering kabiny gdy jest oddzielnym modelem i ma byc wyswietlana
//ABu: tylko w trybie FreeFly, zwykly tryb w world.cpp
//Ra: świetła są ustawione dla zewnętrza danego pojazdu
//oswietlenie kabiny
GLfloat ambientCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat diffuseCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat specularCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
for (int li=0; li<3; li++)
{
ambientCabLight[li]= Global::ambientDayLight[li]*0.9;
diffuseCabLight[li]= Global::diffuseDayLight[li]*0.5;
specularCabLight[li]=Global::specularDayLight[li]*0.5;
}
switch (MyTrack->eEnvironment)
{
case e_canyon:
{
for (int li=0; li<3; li++)
{
diffuseCabLight[li]*= 0.6;
specularCabLight[li]*= 0.7;
}
}
break;
case e_tunnel:
{
for (int li=0; li<3; li++)
{
ambientCabLight[li]*= 0.3;
diffuseCabLight[li]*= 0.1;
specularCabLight[li]*= 0.2;
}
}
break;
}
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientCabLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseCabLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularCabLight);
if (Global::bUseVBO)
mdKabina->RaRender(ObjSqrDist,0);
else
mdKabina->Render(ObjSqrDist,0);
glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight);
}
if (fShade!=0.0) //tylko jeśli było zmieniane
{//przywrócenie standardowego oświetlenia
glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight);
}
glPopMatrix();
if (btnOn) TurnOff(); //przywrócenie domyślnych pozycji submodeli
} //yB - koniec mieszania z grafika
};
void __fastcall TDynamicObject::RenderSounds()
{//przeliczanie dźwięków, bo będzie słychać bez wyświetlania sektora z pojazdem
//McZapkie-010302: ulepszony dzwiek silnika
double freq;
double vol=0;
double dt=Timer::GetDeltaTime();
// double sounddist;
// sounddist=SquareMagnitude(Global::pCameraPosition-vPosition);
if (MoverParameters->Power>0)
{
if ((rsSilnik.AM!=0) && ((MoverParameters->Mains) || (MoverParameters->EngineType==DieselEngine))) //McZapkie-280503: zeby dla dumb dzialal silnik na jalowych obrotach
{
if ((fabs(MoverParameters->enrot)>0.01) || (MoverParameters->EngineType==Dumb)) //&& (MoverParameters->EnginePower>0.1))
{
freq=rsSilnik.FM*fabs(MoverParameters->enrot)+rsSilnik.FA;
if (MoverParameters->EngineType==Dumb)
freq=freq-0.2*MoverParameters->EnginePower/(1+MoverParameters->Power*1000);
rsSilnik.AdjFreq(freq,dt);
if (MoverParameters->EngineType==DieselEngine)
{
if (MoverParameters->enrot>0)
{
if (MoverParameters->EnginePower>0)
vol=rsSilnik.AM*MoverParameters->dizel_fill+rsSilnik.AA;
else
vol=rsSilnik.AM*fabs(MoverParameters->enrot/MoverParameters->nmax)+rsSilnik.AA*0.9;
}
else
vol=0;
}
else if (MoverParameters->EngineType==DieselElectric)
vol=rsSilnik.AM*(MoverParameters->EnginePower/1000/MoverParameters->Power)+0.2*(MoverParameters->enrot*60)/(MoverParameters->DElist[MoverParameters->MainCtrlPosNo].RPM)+rsSilnik.AA;
else if (MoverParameters->EngineType==ElectricInductionMotor)
vol=rsSilnik.AM*(MoverParameters->EnginePower+fabs(MoverParameters->enrot*2))+rsSilnik.AA;
else
vol=rsSilnik.AM*(MoverParameters->EnginePower/1000+fabs(MoverParameters->enrot)*60.0)+rsSilnik.AA;
// McZapkie-250302 - natezenie zalezne od obrotow i mocy
if ((vol<1) && (MoverParameters->EngineType==ElectricSeriesMotor) && (MoverParameters->EnginePower<100))
{
float volrnd=random(100)*MoverParameters->enrot/(1+MoverParameters->nmax);
if (volrnd<2)
vol=vol+volrnd/200.0;
}
switch (MyTrack->eEnvironment)
{
case e_tunnel:
{
vol+=0.1;
}
break;
case e_canyon:
{
vol+=0.05;
}
break;
}
if ((MoverParameters->DynamicBrakeFlag) && (MoverParameters->EnginePower>0.1) && (MoverParameters->EngineType==ElectricSeriesMotor)) //Szociu - 29012012 - jeżeli uruchomiony jest hamulec elektrodynamiczny, odtwarzany jest dźwięk silnika
vol +=0.8;
if (enginevolume>0.0001)
if (MoverParameters->EngineType!=DieselElectric)
{ rsSilnik.Play(enginevolume,DSBPLAY_LOOPING,MechInside,GetPosition()); }
else
{
sConverter.UpdateAF(vol,freq,MechInside,GetPosition());
float fincvol;
fincvol=0;
if ((MoverParameters->ConverterFlag)&&(MoverParameters->enrot*60>MoverParameters->DElist[0].RPM))
{
fincvol=(MoverParameters->DElist[MoverParameters->MainCtrlPos].RPM-(MoverParameters->enrot*60));
fincvol/=(0.05*MoverParameters->DElist[0].RPM);
};
if (fincvol>0.02)
rsDiesielInc.Play(fincvol,DSBPLAY_LOOPING,MechInside,GetPosition());
else
rsDiesielInc.Stop();
}
}
else
rsSilnik.Stop();
}
enginevolume=(enginevolume+vol)/2;
if (enginevolume<0.01)
rsSilnik.Stop();
if ((MoverParameters->EngineType==ElectricSeriesMotor)||(MoverParameters->EngineType==ElectricInductionMotor) && rsWentylator.AM!=0)
{
if (MoverParameters->RventRot>0.1)
{
freq=rsWentylator.FM*MoverParameters->RventRot+rsWentylator.FA;
rsWentylator.AdjFreq(freq,dt);
if (MoverParameters->EngineType==ElectricInductionMotor)
vol=rsWentylator.AM*sqrt(fabs(MoverParameters->dizel_fill))+rsWentylator.AA;
else
vol=rsWentylator.AM*MoverParameters->RventRot+rsWentylator.AA;
rsWentylator.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition());
}
else
rsWentylator.Stop();
}
if (MoverParameters->TrainType==dt_ET40)
{
if (MoverParameters->Vel>0.1)
{
freq=rsPrzekladnia.FM*(MoverParameters->Vel)+rsPrzekladnia.FA;
rsPrzekladnia.AdjFreq(freq,dt);
vol=rsPrzekladnia.AM*(MoverParameters->Vel)+rsPrzekladnia.AA;
rsPrzekladnia.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition());
}
else
rsPrzekladnia.Stop();
}
}
//youBy: dzwiek ostrych lukow i ciasnych zwrotek
if ((ts.R*ts.R>1)&&(MoverParameters->Vel>0))
vol=MoverParameters->AccN*MoverParameters->AccN;
else
vol=0;
// vol+=(50000/ts.R*ts.R);
if (vol>0.001)
{
rscurve.Play(2*vol,DSBPLAY_LOOPING,MechInside,GetPosition());
}
else
rscurve.Stop();
//McZapkie-280302 - pisk mocno zacisnietych hamulcow - trzeba jeszcze zabezpieczyc przed brakiem deklaracji w mmedia.dta
if (rsPisk.AM!=0)
{
if ((MoverParameters->Vel>(rsPisk.GetStatus()!=0?0.01:0.5)) && (!MoverParameters->SlippingWheels) && (MoverParameters->UnitBrakeForce>rsPisk.AM))
{
vol=MoverParameters->UnitBrakeForce/(rsPisk.AM+1)+rsPisk.AA;
rsPisk.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition());
}
else
rsPisk.Stop();
}
//if ((MoverParameters->ConverterFlag==false) && (MoverParameters->TrainType!=dt_ET22))
//if ((MoverParameters->ConverterFlag==false)&&(MoverParameters->CompressorPower!=0))
// MoverParameters->CompressorFlag=false; //Ra: wywalić to stąd, tu tylko dla wyświetlanych!
//Ra: no to już wiemy, dlaczego pociągi jeżdżą lepiej, gdy się na nie patrzy!
//if (MoverParameters->CompressorPower==2)
// MoverParameters->CompressorAllow=MoverParameters->ConverterFlag;
// McZapkie! - dzwiek compressor.wav tylko gdy dziala sprezarka
if (MoverParameters->VeselVolume!=0)
{
if (MoverParameters->CompressorFlag)
sCompressor.TurnOn(MechInside,GetPosition());
else
sCompressor.TurnOff(MechInside,GetPosition());
sCompressor.Update(MechInside,GetPosition());
}
if (MoverParameters->PantCompFlag) // Winger 160404 - dzwiek malej sprezarki
sSmallCompressor.TurnOn(MechInside,GetPosition());
else
sSmallCompressor.TurnOff(MechInside,GetPosition());
sSmallCompressor.Update(MechInside,GetPosition());
//youBy - przenioslem, bo diesel tez moze miec turbo
if ((MoverParameters->MainCtrlPos)>=(MoverParameters->TurboTest)) //hunter-250312: dlaczego zakomentowane? Ra: bo nie działało dobrze
{
//udawanie turbo: (6.66*(eng_vol-0.85))
if (eng_turbo>6.66*(enginevolume-0.8)+0.2*dt)
eng_turbo=eng_turbo-0.2*dt; //0.125
else
if (eng_turbo<6.66*(enginevolume-0.8)-0.4*dt)
eng_turbo=eng_turbo+0.4*dt; //0.333
else
eng_turbo=6.66*(enginevolume-0.8);
sTurbo.TurnOn(MechInside,GetPosition());
//sTurbo.UpdateAF(eng_turbo,0.7+(eng_turbo*0.6),MechInside,GetPosition());
sTurbo.UpdateAF(3*eng_turbo-1,0.4+eng_turbo*0.4,MechInside,GetPosition());
// eng_vol_act=enginevolume;
//eng_frq_act=eng_frq;
}
else sTurbo.TurnOff(MechInside,GetPosition());
if (MoverParameters->TrainType==dt_PseudoDiesel)
{
//ABu: udawanie woodwarda dla lok. spalinowych
//jesli silnik jest podpiety pod dzwiek przetwornicy
if (MoverParameters->ConverterFlag) //NBMX dzwiek przetwornicy
{
sConverter.TurnOn(MechInside,GetPosition());
}
else
sConverter.TurnOff(MechInside,GetPosition());
//glosnosc zalezy od stosunku mocy silnika el. do mocy max
double eng_vol;
if (MoverParameters->Power>1)
//0.85+0.000015*(...)
eng_vol=0.8+0.00002*(MoverParameters->EnginePower/MoverParameters->Power);
else
eng_vol=1;
eng_dfrq=eng_dfrq+(eng_vol_act-eng_vol);
if(eng_dfrq>0)
{
eng_dfrq=eng_dfrq-0.025*dt;
if(eng_dfrq<0.025*dt)
eng_dfrq=0;
}
else
if(eng_dfrq<0)
{
eng_dfrq=eng_dfrq+0.025*dt;
if(eng_dfrq>-0.025*dt)
eng_dfrq=0;
}
double defrot;
if (MoverParameters->MainCtrlPos!=0)
{
double CtrlPos=MoverParameters->MainCtrlPos;
double CtrlPosNo=MoverParameters->MainCtrlPosNo;
//defrot=1+0.4*(CtrlPos/CtrlPosNo);
defrot=1+0.5*(CtrlPos/CtrlPosNo);
}
else
defrot=1;
if (eng_frq_act<defrot)
{
//if (MoverParameters->MainCtrlPos==1) eng_frq_act=eng_frq_act+0.1*dt;
eng_frq_act=eng_frq_act+0.4*dt; //0.05
if (eng_frq_act>defrot-0.4*dt)
eng_frq_act=defrot;
}
else
if (eng_frq_act>defrot)
{
eng_frq_act=eng_frq_act-0.1*dt; //0.05
if (eng_frq_act<defrot+0.1*dt)
eng_frq_act=defrot;
}
sConverter.UpdateAF(eng_vol_act,eng_frq_act+eng_dfrq,MechInside,GetPosition());
//udawanie turbo: (6.66*(eng_vol-0.85))
if (eng_turbo>6.66*(eng_vol-0.8)+0.2*dt)
eng_turbo=eng_turbo-0.2*dt; //0.125
else
if (eng_turbo<6.66*(eng_vol-0.8)-0.4*dt)
eng_turbo=eng_turbo+0.4*dt; //0.333
else
eng_turbo=6.66*(eng_vol-0.8);
sTurbo.TurnOn(MechInside,GetPosition());
//sTurbo.UpdateAF(eng_turbo,0.7+(eng_turbo*0.6),MechInside,GetPosition());
sTurbo.UpdateAF(3*eng_turbo-1,0.4+eng_turbo*0.4,MechInside,GetPosition());
eng_vol_act=eng_vol;
//eng_frq_act=eng_frq;
}
else
{
if (MoverParameters->ConverterFlag) //NBMX dzwiek przetwornicy
sConverter.TurnOn(MechInside,GetPosition());
else
sConverter.TurnOff(MechInside,GetPosition());
sConverter.Update(MechInside,GetPosition());
}
if (MoverParameters->WarningSignal>0)
{
if (TestFlag(MoverParameters->WarningSignal,1))
sHorn1.TurnOn(MechInside,GetPosition());
else
sHorn1.TurnOff(MechInside,GetPosition());
if (TestFlag(MoverParameters->WarningSignal,2))
sHorn2.TurnOn(MechInside,GetPosition());
else
sHorn2.TurnOff(MechInside,GetPosition());
}
else
{
sHorn1.TurnOff(MechInside,GetPosition());
sHorn2.TurnOff(MechInside,GetPosition());
}
if (MoverParameters->DoorClosureWarning)
{
if (MoverParameters->DepartureSignal) //NBMX sygnal odjazdu, MC: pod warunkiem ze jest zdefiniowane w chk
sDepartureSignal.TurnOn(MechInside,GetPosition());
else
sDepartureSignal.TurnOff(MechInside,GetPosition());
sDepartureSignal.Update(MechInside,GetPosition());
}
sHorn1.Update(MechInside,GetPosition());
sHorn2.Update(MechInside,GetPosition());
//McZapkie: w razie wykolejenia
if (MoverParameters->EventFlag)
{
if (TestFlag(MoverParameters->DamageFlag,dtrain_out) && GetVelocity()>0)
rsDerailment.Play(1,0,true,GetPosition());
if (GetVelocity()==0)
rsDerailment.Stop();
}
/* //Ra: dwa razy?
if (MoverParameters->EventFlag)
{
if (TestFlag(MoverParameters->DamageFlag,dtrain_out) && GetVelocity()>0)
rsDerailment.Play(1,0,true,GetPosition());
if (GetVelocity()==0)
rsDerailment.Stop();
}
*/
};
void __fastcall TDynamicObject::RenderAlpha()
{//rysowanie elementów półprzezroczystych
if (renderme)
{
TSubModel::iInstance=(int)this; //żeby nie robić cudzych animacji
double ObjSqrDist=SquareMagnitude(Global::pCameraPosition-vPosition);
ABuLittleUpdate(ObjSqrDist); //ustawianie zmiennych submodeli dla wspólnego modelu
glPushMatrix();
if (this==Global::pUserDynamic)
{//specjalne ustawienie, aby nie trzęsło
if (Global::bSmudge)
{//jak smuga, to rysować po smudze
glPopMatrix(); //to trzeba zebrać przed wyściem
return;
}
glLoadIdentity(); //zacząć od macierzy jedynkowej
Global::pCamera->SetCabMatrix(vPosition); //specjalne ustawienie kamery
}
else
glTranslated(vPosition.x,vPosition.y,vPosition.z); //standardowe przesunięcie względem początku scenerii
glMultMatrixd(mMatrix.getArray());
if (fShade>0.0)
{//Ra: zmiana oswietlenia w tunelu, wykopie
GLfloat ambientLight[4]= {0.5f,0.5f,0.5f,1.0f};
GLfloat diffuseLight[4]= {0.5f,0.5f,0.5f,1.0f};
GLfloat specularLight[4]={0.5f,0.5f,0.5f,1.0f};
//trochę problem z ambientem w wykopie...
for (int li=0;li<3;li++)
{
ambientLight[li]= Global::ambientDayLight[li]*fShade;
diffuseLight[li]= Global::diffuseDayLight[li]*fShade;
specularLight[li]=Global::specularDayLight[li]*fShade;
}
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);
}
if (Global::bUseVBO)
{//wersja VBO
if (mdLowPolyInt)
if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab)
mdLowPolyInt->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
mdModel->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdLoad)
mdLoad->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
//if (mdPrzedsionek) //Ra: przedsionków tu wcześniej nie było - włączyć?
// mdPrzedsionek->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
}
else
{//wersja Display Lists
if (mdLowPolyInt)
if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab)
mdLowPolyInt->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
mdModel->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
if (mdLoad)
mdLoad->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
//if (mdPrzedsionek) //Ra: przedsionków tu wcześniej nie było - włączyć?
// mdPrzedsionek->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha);
}
/* skoro false to można wyciąc
//ABu: Tylko w trybie freefly
if (false)//((mdKabina!=mdModel) && bDisplayCab && FreeFlyModeFlag)
{
//oswietlenie kabiny
GLfloat ambientCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat diffuseCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat specularCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f };
for (int li=0; li<3; li++)
{
ambientCabLight[li]= Global::ambientDayLight[li]*0.9;
diffuseCabLight[li]= Global::diffuseDayLight[li]*0.5;
specularCabLight[li]= Global::specularDayLight[li]*0.5;
}
switch (MyTrack->eEnvironment)
{
case e_canyon:
{
for (int li=0; li<3; li++)
{
diffuseCabLight[li]*= 0.6;
specularCabLight[li]*= 0.8;
}
}
break;
case e_tunnel:
{
for (int li=0; li<3; li++)
{
ambientCabLight[li]*= 0.3;
diffuseCabLight[li]*= 0.1;
specularCabLight[li]*= 0.2;
}
}
break;
}
// dorobic swiatlo od drugiej strony szyby
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientCabLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseCabLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularCabLight);
mdKabina->RenderAlpha(ObjSqrDist,0);
//smierdzi
// mdModel->RenderAlpha(SquareMagnitude(Global::pCameraPosition-pos),0);
glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight);
}
*/
if (fShade!=0.0) //tylko jeśli było zmieniane
{//przywrócenie standardowego oświetlenia
glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight);
}
glPopMatrix();
if (btnOn) TurnOff(); //przywrócenie domyślnych pozycji submodeli
}
return;
} //koniec renderalpha
//McZapkie-250202
//wczytywanie pliku z danymi multimedialnymi (dzwieki)
void __fastcall TDynamicObject::LoadMMediaFile(AnsiString BaseDir,AnsiString TypeName,AnsiString ReplacableSkin)
{
double dSDist;
TFileStream *fs;
//asBaseDir=BaseDir;
Global::asCurrentDynamicPath=BaseDir;
AnsiString asFileName=BaseDir+TypeName+".mmd";
AnsiString asLoadName=BaseDir+MoverParameters->LoadType+".t3d";
if (!FileExists(asFileName))
{
ErrorLog("Missed file: "+asFileName); //brak MMD
return;
}
fs=new TFileStream(asFileName,fmOpenRead|fmShareCompat);
if (!fs) return;
int size=fs->Size;
if (!size) {return delete fs;};
AnsiString asAnimName;
bool Stop_InternalData=false;
char* buf=new char[size+1]; //ciąg bajtów o długości równej rozmiwarowi pliku
buf[size]='\0'; //zakończony zerem na wszelki wypadek
fs->Read(buf,size);
delete fs;
TQueryParserComp *Parser;
Parser=new TQueryParserComp(NULL);
Parser->TextToParse=AnsiString(buf);
delete[] buf;
AnsiString str;
//Parser->LoadStringToParse(asFile);
Parser->First();
//DecimalSeparator= '.';
pants=NULL; //wskaźnik pierwszego obiektu animującego dla pantografów
int i;
while (!Parser->EndOfFile && !Stop_InternalData)
{
str=Parser->GetNextSymbol().LowerCase();
if (str==AnsiString("models:")) //modele i podmodele
{
iMultiTex=0; //czy jest wiele tekstur wymiennych?
asModel=Parser->GetNextSymbol().LowerCase();
if (asModel.Pos("#")==asModel.Length()) //Ra 2015-01: nie podoba mi się to
{//model wymaga wielu tekstur wymiennych
iMultiTex=1;
asModel=asModel.SubString(1,asModel.Length()-1);
}
if ((i=asModel.Pos(","))>0)
{//Ra 2015-01: może szukać przecinka w nazwie modelu, a po przecinku była by liczba tekstur?
if (i<asModel.Length())
iMultiTex=asModel[i+1]-'0';
if (iMultiTex<0) iMultiTex=0; else if (iMultiTex>1) iMultiTex=1; //na razie ustawiamy na 1
}
asModel=BaseDir+asModel; //McZapkie 2002-07-20: dynamics maja swoje modele w dynamics/basedir
Global::asCurrentTexturePath=BaseDir; //biezaca sciezka do tekstur to dynamic/...
mdModel=TModelsManager::GetModel(asModel.c_str(),true);
if (ReplacableSkin!=AnsiString("none"))
{//tekstura wymienna jest raczej jedynie w "dynamic\"
ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //skory tez z dynamic/...
if ((i=ReplacableSkin.Pos("|"))>0) //replacable dzielone
{iMultiTex=-1;
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską
ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki
//sprawdzić, ile jest i ustawić iMultiTex na liczbę podanych tekstur
if (!ReplacableSkin.IsEmpty())
{//próba wycięcia drugiej nazwy
iMultiTex=-2; //skoro zostało coś po kresce, to są co najmniej dwie
if ((i=ReplacableSkin.Pos("|"))==0) //gdy nie ma już kreski
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
else
{//jak jest kreska, to wczytać drugą i próbować trzecią
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską
ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki
if (!ReplacableSkin.IsEmpty())
{//próba wycięcia trzeciej nazwy
iMultiTex=-3; //skoro zostało coś po kresce, to są co najmniej trzy
if ((i=ReplacableSkin.Pos("|"))==0) //gdy nie ma już kreski
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
else
{//jak jest kreska, to wczytać trzecią i próbować czwartą
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską
ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki
if (!ReplacableSkin.IsEmpty())
{//próba wycięcia trzeciej nazwy
iMultiTex=-4; //skoro zostało coś po kresce, to są co najmniej cztery
ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering);
//więcej na razie nie zadziała, a u tak trzeba to do modeli przenieść
}
}
}
}
}
}
if (iMultiTex>0)
{//jeśli model ma 4 tekstury
ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",1").c_str(),Global::iDynamicFiltering);
if (ReplacableSkinID[1])
{//pierwsza z zestawu znaleziona
ReplacableSkinID[2]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",2").c_str(),Global::iDynamicFiltering);
if (ReplacableSkinID[2])
{iMultiTex=2; //już są dwie
ReplacableSkinID[3]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",3").c_str(),Global::iDynamicFiltering);
if (ReplacableSkinID[3])
{iMultiTex=3; //a teraz nawet trzy
ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",4").c_str(),Global::iDynamicFiltering);
if (ReplacableSkinID[4]) iMultiTex=4; //jak są cztery, to blokujemy podmianę tekstury rozkładem
}
}
}
else
{//zestaw nie zadziałał, próbujemy normanie
iMultiTex=0;
ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.c_str(),Global::iDynamicFiltering);
}
}
else
ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.c_str(),Global::iDynamicFiltering);
if (TTexturesManager::GetAlpha(ReplacableSkinID[1]))
iAlpha=0x31310031; //tekstura -1 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
else
iAlpha=0x30300030; //wszystkie tekstury nieprzezroczyste - nie renderować w cyklu przezroczystych
if (ReplacableSkinID[2])
if (TTexturesManager::GetAlpha(ReplacableSkinID[2]))
iAlpha|=0x02020002; //tekstura -2 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
if (ReplacableSkinID[3])
if (TTexturesManager::GetAlpha(ReplacableSkinID[3]))
iAlpha|=0x04040004; //tekstura -3 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
if (ReplacableSkinID[4])
if (TTexturesManager::GetAlpha(ReplacableSkinID[4]))
iAlpha|=0x08080008; //tekstura -4 z kanałem alfa - nie renderować w cyklu nieprzezroczystych
}
//Winger 040304 - ladowanie przedsionkow dla EZT
if (MoverParameters->TrainType==dt_EZT)
{
asModel="przedsionki.t3d";
asModel=BaseDir+asModel;
mdPrzedsionek=TModelsManager::GetModel(asModel.c_str(),true);
}
if (!MoverParameters->LoadAccepted.IsEmpty())
//if (MoverParameters->LoadAccepted!=AnsiString("")); // && MoverParameters->LoadType!=AnsiString("passengers"))
if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector)
{//wartość niby "pantstate" - nazwa dla formalności, ważna jest ilość
if (MoverParameters->Load==1)
MoverParameters->PantFront(true);
else if (MoverParameters->Load==2)
MoverParameters->PantRear(true);
else if (MoverParameters->Load==3)
{
MoverParameters->PantFront(true);
MoverParameters->PantRear(true);
}
else if (MoverParameters->Load==4)
MoverParameters->DoubleTr=-1;
else if (MoverParameters->Load==5)
{
MoverParameters->DoubleTr=-1;
MoverParameters->PantRear(true);
}
else if (MoverParameters->Load==6)
{
MoverParameters->DoubleTr=-1;
MoverParameters->PantFront(true);
}
else if (MoverParameters->Load==7)
{
MoverParameters->DoubleTr=-1;
MoverParameters->PantFront(true);
MoverParameters->PantRear(true);
}
}
else //Ra: tu wczytywanie modelu ładunku jest w porządku
mdLoad=TModelsManager::GetModel(asLoadName.c_str(),true); //ladunek
Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur
while (!Parser->EndOfFile && str!=AnsiString("endmodels"))
{
str=Parser->GetNextSymbol().LowerCase();
if (str==AnsiString("animations:"))
{//Ra: ustawienie ilości poszczególnych animacji - musi być jako pierwsze, inaczej ilości będą domyślne
if (!pAnimations)
{//jeśli nie ma jeszcze tabeli animacji, można odczytać nowe ilości
int co=0,ile;
iAnimations=0;
do
{//kolejne liczby to ilość animacj, -1 to znacznik końca
ile=Parser->GetNextSymbol().ToIntDef(-1); //ilość danego typu animacji
//if (co==ANIM_PANTS)
// if (!Global::bLoadTraction)
// if (!DebugModeFlag) //w debugmode pantografy mają "niby działać"
// ile=0; //wyłączenie animacji pantografów
if (co<ANIM_TYPES)
if (ile>=0)
{iAnimType[co]=ile; //zapamiętanie
iAnimations+=ile; //ogólna ilość animacji
}
++co;
} while (ile>=0); //-1 to znacznik końca
while (co<ANIM_TYPES) iAnimType[co++]=0; //zerowanie pozostałych
str=Parser->GetNextSymbol().LowerCase();
}
//WriteLog("Total animations: "+AnsiString(iAnimations));
}
if (!pAnimations)
{//Ra: tworzenie tabeli animacji, jeśli jeszcze nie było
if (!iAnimations) //jeśli nie podano jawnie, ile ma być animacji
iAnimations=28; //tyle było kiedyś w każdym pojeździe (2 wiązary wypadły)
/* //pojazd może mieć pantograf do innych celów niż napęd
if (MoverParameters->EnginePowerSource.SourceType!=CurrentCollector)
{//nie będzie pantografów, to się trochę uprości
iAnimations-=iAnimType[ANIM_PANTS]; //domyślnie były 2 pantografy
iAnimType[ANIM_PANTS]=0;
}
*/
pAnimations=new TAnim[iAnimations];
int i,j,k=0,sm=0;
for (j=0;j<ANIM_TYPES;++j)
for (i=0;i<iAnimType[j];++i)
{
if (j==ANIM_PANTS) //zliczamy poprzednie animacje
if (!pants)
if (iAnimType[ANIM_PANTS]) //o ile jakieś pantografy są (a domyślnie są)
pants=pAnimations+k; //zapamiętanie na potrzeby wyszukania submodeli
pAnimations[k].iShift=sm; //przesunięcie do przydzielenia wskaźnika
sm+=pAnimations[k++].TypeSet(j); //ustawienie typu animacji i zliczanie tablicowanych submodeli
}
if (sm) //o ile są bardziej złożone animacje
{pAnimated=new TSubModel*[sm]; //tabela na animowane submodele
for (k=0;k<iAnimations;++k)
pAnimations[k].smElement=pAnimated+pAnimations[k].iShift; //przydzielenie wskaźnika do tabelki
}
}
if (str==AnsiString("lowpolyinterior:")) //ABu: wnetrze lowpoly
{
asModel=Parser->GetNextSymbol().LowerCase();
asModel=BaseDir+asModel; //McZapkie-200702 - dynamics maja swoje modele w dynamic/basedir
Global::asCurrentTexturePath=BaseDir; //biezaca sciezka do tekstur to dynamic/...
mdLowPolyInt=TModelsManager::GetModel(asModel.c_str(),true);
//Global::asCurrentTexturePath=AnsiString(szTexturePath); //kiedyś uproszczone wnętrze mieszało tekstury nieba
}
if (str==AnsiString("brakemode:"))
{//Ra 15-01: gałka nastawy hamulca
asAnimName=Parser->GetNextSymbol().LowerCase();
smBrakeMode=mdModel->GetFromName(asAnimName.c_str());
//jeszcze wczytać kąty obrotu dla poszczególnych ustawień
}
if (str==AnsiString("loadmode:"))
{//Ra 15-01: gałka nastawy hamulca
asAnimName=Parser->GetNextSymbol().LowerCase();
smLoadMode=mdModel->GetFromName(asAnimName.c_str());
//jeszcze wczytać kąty obrotu dla poszczególnych ustawień
}
else if (str==AnsiString("animwheelprefix:"))
{//prefiks kręcących się kół
int i,j,k,m;
str=Parser->GetNextSymbol();
for (i=0;i<iAnimType[ANIM_WHEELS];++i) //liczba osi
{//McZapkie-050402: wyszukiwanie kol o nazwie str*
asAnimName=str+AnsiString(i+1);
pAnimations[i].smAnimated=mdModel->GetFromName(asAnimName.c_str()); //ustalenie submodelu
if (pAnimations[i].smAnimated)
{//++iAnimatedAxles;
pAnimations[i].smAnimated->WillBeAnimated(); //wyłączenie optymalizacji transformu
pAnimations[i].yUpdate=UpdateAxle; //animacja osi
pAnimations[i].fMaxDist=50*MoverParameters->WheelDiameter; //nie kręcić w większej odległości
pAnimations[i].fMaxDist*=pAnimations[i].fMaxDist*MoverParameters->WheelDiameter; //50m do kwadratu, a średnica do trzeciej
pAnimations[i].fMaxDist*=Global::fDistanceFactor; //współczynnik przeliczeniowy jakości ekranu
}
}
//Ra: ustawianie indeksów osi
for (i=0;i<iAnimType[ANIM_WHEELS];++i) //ilość osi (zabezpieczenie przed błędami w CHK)
pAnimations[i].dWheelAngle=dWheelAngle+1; //domyślnie wskaźnik na napędzające
i=0; j=1; k=0; m=0; //numer osi; kolejny znak; ile osi danego typu; która średnica
if ((MoverParameters->WheelDiameterL!=MoverParameters->WheelDiameter)||(MoverParameters->WheelDiameterT!=MoverParameters->WheelDiameter))
{//obsługa różnych średnic, o ile występują
while ((i<iAnimType[ANIM_WHEELS])&&(j<=MoverParameters->AxleArangement.Length()))
{//wersja ze wskaźnikami jest bardziej elastyczna na nietypowe układy
if ((k>='A')&&(k<='J')) //10 chyba maksimum?
{pAnimations[i++].dWheelAngle=dWheelAngle+1; //obrót osi napędzających
--k; //następna będzie albo taka sama, albo bierzemy kolejny znak
m=2; //następujące toczne będą miały inną średnicę
}
else if ((k>='1')&&(k<='9'))
{pAnimations[i++].dWheelAngle=dWheelAngle+m; //obrót osi tocznych
--k; //następna będzie albo taka sama, albo bierzemy kolejny znak
}
else
k=MoverParameters->AxleArangement[j++]; //pobranie kolejnego znaku
}
}
}
//else if (str==AnsiString("animrodprefix:")) //prefiks wiazarow dwoch
// {
// str= Parser->GetNextSymbol();
// for (int i=1; i<=2; i++)
// {//McZapkie-050402: wyszukiwanie max 2 wiazarow o nazwie str*
// asAnimName=str+i;
// smWiazary[i-1]=mdModel->GetFromName(asAnimName.c_str());
// smWiazary[i-1]->WillBeAnimated();
// }
// }
else if (str==AnsiString("animpantprefix:"))
{//Ra: pantografy po nowemu mają literki i numerki
}
//Pantografy - Winger 160204
if (str==AnsiString("animpantrd1prefix:"))
{//prefiks ramion dolnych 1
str=Parser->GetNextSymbol();
float4x4 m; //macierz do wyliczenia pozycji i wektora ruchu pantografu
TSubModel *sm;
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];i++)
{//Winger 160204: wyszukiwanie max 2 patykow o nazwie str*
asAnimName=str+AnsiString(i+1);
sm=mdModel->GetFromName(asAnimName.c_str());
pants[i].smElement[0]=sm; //jak NULL, to nie będzie animowany
if (sm)
{//w EP09 wywalało się tu z powodu NULL
sm->WillBeAnimated();
sm->ParentMatrix(&m); //pobranie macierzy transformacji
//m(3)[1]=m[3][1]+0.054; //w górę o wysokość ślizgu (na razie tak)
if ((mdModel->Flags()&0x8000)==0) //jeśli wczytano z T3D
m.InitialRotate(); //może być potrzebny dodatkowy obrót, jeśli wczytano z T3D, tzn. przed wykonaniem Init()
pants[i].fParamPants->vPos.z=m[3][0]; //przesunięcie w bok (asymetria)
pants[i].fParamPants->vPos.y=m[3][1]; //przesunięcie w górę odczytane z modelu
if ((sm=pants[i].smElement[0]->ChildGet())!=NULL)
{//jeśli ma potomny, można policzyć długość (odległość potomnego od osi obrotu)
m=float4x4(*sm->GetMatrix()); //wystarczyłby wskaźnik, nie trzeba kopiować
//może trzeba: pobrać macierz dolnego ramienia, wyzerować przesunięcie, przemnożyć przez macierz górnego
pants[i].fParamPants->fHoriz=-fabs(m[3][1]);
pants[i].fParamPants->fLenL1=hypot(m[3][1],m[3][2]); //po osi OX nie potrzeba
pants[i].fParamPants->fAngleL0=atan2(fabs(m[3][2]),fabs(m[3][1]));
//if (pants[i].fParamPants->fAngleL0<M_PI_2) pants[i].fParamPants->fAngleL0+=M_PI; //gdyby w odwrotną stronę wyszło
//if ((pants[i].fParamPants->fAngleL0<0.03)||(pants[i].fParamPants->fAngleL0>0.09)) //normalnie ok. 0.05
// pants[i].fParamPants->fAngleL0=pants[i].fParamPants->fAngleL;
pants[i].fParamPants->fAngleL=pants[i].fParamPants->fAngleL0; //początkowy kąt dolnego ramienia
if ((sm=sm->ChildGet())!=NULL)
{//jeśli dalej jest ślizg, można policzyć długość górnego ramienia
m=float4x4(*sm->GetMatrix()); //wystarczyłby wskaźnik, nie trzeba kopiować
//trzeba by uwzględnić macierz dolnego ramienia, żeby uzyskać kąt do poziomu...
pants[i].fParamPants->fHoriz+=fabs(m(3)[1]); //różnica długości rzutów ramion na płaszczyznę podstawy (jedna dodatnia, druga ujemna)
pants[i].fParamPants->fLenU1=hypot(m[3][1],m[3][2]); //po osi OX nie potrzeba
//pants[i].fParamPants->pantu=acos((1.22*cos(pants[i].fParamPants->fAngleL)+0.535)/1.755); //górne ramię
//pants[i].fParamPants->fAngleU0=acos((1.176289*cos(pants[i].fParamPants->fAngleL)+0.54555075)/1.724482197); //górne ramię
pants[i].fParamPants->fAngleU0=atan2(fabs(m[3][2]),fabs(m[3][1])); //początkowy kąt górnego ramienia, odczytany z modelu
//if (pants[i].fParamPants->fAngleU0<M_PI_2) pants[i].fParamPants->fAngleU0+=M_PI; //gdyby w odwrotną stronę wyszło
//if (pants[i].fParamPants->fAngleU0<0)
// pants[i].fParamPants->fAngleU0=-pants[i].fParamPants->fAngleU0;
//if ((pants[i].fParamPants->fAngleU0<0.00)||(pants[i].fParamPants->fAngleU0>0.09)) //normalnie ok. 0.07
// pants[i].fParamPants->fAngleU0=acos((pants[i].fParamPants->fLenL1*cos(pants[i].fParamPants->fAngleL)+pants[i].fParamPants->fHoriz)/pants[i].fParamPants->fLenU1);
pants[i].fParamPants->fAngleU=pants[i].fParamPants->fAngleU0; //początkowy kąt
//Ra: ze względu na to, że niektóre modele pantografów są zrąbane, ich mierzenie ma obecnie ograniczony sens
sm->ParentMatrix(&m); //pobranie macierzy transformacji pivota ślizgu względem wstawienia pojazdu
if ((mdModel->Flags()&0x8000)==0) //jeśli wczytano z T3D
m.InitialRotate(); //może być potrzebny dodatkowy obrót, jeśli wczytano z T3D, tzn. przed wykonaniem Init()
float det=Det(m);
if (fabs(det-1.0)<0.001) //dopuszczamy 1 promil błędu na skalowaniu ślizgu
{//skalowanie jest w normie, można pobrać wymiary z modelu
pants[i].fParamPants->fHeight=sm->MaxY(m); //przeliczenie maksimum wysokości wierzchołków względem macierzy
pants[i].fParamPants->fHeight-=m[3][1]; //odjęcie wysokości pivota ślizgu
pants[i].fParamPants->vPos.x=m[3][2]; //przy okazji odczytać z modelu pozycję w długości
//ErrorLog("Model OK: "+asModel+", height="+pants[i].fParamPants->fHeight);
//ErrorLog("Model OK: "+asModel+", pos.x="+pants[i].fParamPants->vPos.x);
}
else
{//gdy ktoś przesadził ze skalowaniem
pants[i].fParamPants->fHeight=0.0; //niech będzie odczyt z pantfactors:
ErrorLog("Bad model: "+asModel+", scale of "+AnsiString(sm->pName)+" is "+AnsiString(100.0*det)+"%");
}
}
}
}
else
ErrorLog("Bad model: "+asFileName+" - missed submodel "+asAnimName); //brak ramienia
}
}
else if (str==AnsiString("animpantrd2prefix:"))
{//prefiks ramion dolnych 2
str=Parser->GetNextSymbol();
float4x4 m; //macierz do wyliczenia pozycji i wektora ruchu pantografu
TSubModel *sm;
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];i++)
{//Winger 160204: wyszukiwanie max 2 patykow o nazwie str*
asAnimName=str+AnsiString(i+1);
sm=mdModel->GetFromName(asAnimName.c_str());
pants[i].smElement[1]=sm; //jak NULL, to nie będzie animowany
if (sm)
{//w EP09 wywalało się tu z powodu NULL
sm->WillBeAnimated();
if (pants[i].fParamPants->vPos.y==0.0)
{//jeśli pierwsze ramię nie ustawiło tej wartości, próbować drugim
//!!!! docelowo zrobić niezależną animację ramion z każdej strony
m=float4x4(*sm->GetMatrix()); //skopiowanie, bo będziemy mnożyć
m(3)[1]=m[3][1]+0.054; //w górę o wysokość ślizgu (na razie tak)
while (sm->Parent)
{
if (sm->Parent->GetMatrix())
m=*sm->Parent->GetMatrix()*m;
sm=sm->Parent;
}
pants[i].fParamPants->vPos.z=m[3][0]; //przesunięcie w bok (asymetria)
pants[i].fParamPants->vPos.y=m[3][1]; //przesunięcie w górę odczytane z modelu
}
}
else
ErrorLog("Bad model: "+asFileName+" - missed submodel "+asAnimName); //brak ramienia
}
}
else if (str==AnsiString("animpantrg1prefix:"))
{//prefiks ramion górnych 1
str=Parser->GetNextSymbol();
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];i++)
{//Winger 160204: wyszukiwanie max 2 patykow o nazwie str*
asAnimName=str+AnsiString(i+1);
pants[i].smElement[2]=mdModel->GetFromName(asAnimName.c_str());
pants[i].smElement[2]->WillBeAnimated();
}
}
else
if (str==AnsiString("animpantrg2prefix:"))
{//prefiks ramion górnych 2
str=Parser->GetNextSymbol();
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];i++)
{//Winger 160204: wyszukiwanie max 2 patykow o nazwie str*
asAnimName=str+AnsiString(i+1);
pants[i].smElement[3]=mdModel->GetFromName(asAnimName.c_str());
pants[i].smElement[3]->WillBeAnimated();
}
}
else if (str==AnsiString("animpantslprefix:"))
{//prefiks ślizgaczy
str=Parser->GetNextSymbol();
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];i++)
{//Winger 160204: wyszukiwanie max 2 patykow o nazwie str*
asAnimName=str+AnsiString(i+1);
pants[i].smElement[4]=mdModel->GetFromName(asAnimName.c_str());
pants[i].smElement[4]->WillBeAnimated();
pants[i].yUpdate=UpdatePant;
pants[i].fMaxDist=300*300; //nie podnosić w większej odległości
pants[i].iNumber=i;
}
}
else if (str==AnsiString("pantfactors:"))
{//Winger 010304: parametry pantografow
double pant1x=Parser->GetNextSymbol().ToDouble();
double pant2x=Parser->GetNextSymbol().ToDouble();
double pant1h=Parser->GetNextSymbol().ToDouble(); //wysokość pierwszego ślizgu
double pant2h=Parser->GetNextSymbol().ToDouble(); //wysokość drugiego ślizgu
if (pant1h>0.5) pant1h=pant2h; //tu może być zbyt duża wartość
if ((pant1x<0)&&(pant2x>0)) //pierwsza powinna być dodatnia, a druga ujemna
{pant1x=-pant1x; pant2x=-pant2x;}
if (pants)
for (int i=0;i<iAnimType[ANIM_PANTS];++i)
{//przepisanie współczynników do pantografów (na razie nie będzie lepiej)
pants[i].fParamPants->fAngleL=pants[i].fParamPants->fAngleL0; //początkowy kąt dolnego ramienia
pants[i].fParamPants->fAngleU=pants[i].fParamPants->fAngleU0; //początkowy kąt
//pants[i].fParamPants->PantWys=1.22*sin(pants[i].fParamPants->fAngleL)+1.755*sin(pants[i].fParamPants->fAngleU); //wysokość początkowa
//pants[i].fParamPants->PantWys=1.176289*sin(pants[i].fParamPants->fAngleL)+1.724482197*sin(pants[i].fParamPants->fAngleU); //wysokość początkowa
if (pants[i].fParamPants->fHeight==0.0) //gdy jest nieprawdopodobna wartość (np. nie znaleziony ślizg)
{//gdy pomiary modelu nie udały się, odczyt podanych parametrów z MMD
pants[i].fParamPants->vPos.x=(i&1)?pant2x:pant1x;
pants[i].fParamPants->fHeight=(i&1)?pant2h:pant1h; //wysokość ślizgu jest zapisana w MMD
}
pants[i].fParamPants->PantWys=pants[i].fParamPants->fLenL1*sin(pants[i].fParamPants->fAngleL)+pants[i].fParamPants->fLenU1*sin(pants[i].fParamPants->fAngleU)+pants[i].fParamPants->fHeight; //wysokość początkowa
//pants[i].fParamPants->vPos.y=panty-panth-pants[i].fParamPants->PantWys; //np. 4.429-0.097=4.332=~4.335
//pants[i].fParamPants->vPos.z=0; //niezerowe dla pantografów asymetrycznych
pants[i].fParamPants->PantTraction=pants[i].fParamPants->PantWys;
pants[i].fParamPants->fWidth=0.5*MoverParameters->EnginePowerSource.CollectorParameters.CSW; //połowa szerokości ślizgu; jest w "Power: CSW="
}
}
else if (str==AnsiString("animpistonprefix:"))
{//prefiks tłoczysk - na razie używamy modeli pantografów
str=Parser->GetNextSymbol();
for (int i=1;i<=2;i++)
{
//asAnimName=str+i;
//smPatykird1[i-1]=mdModel->GetFromName(asAnimName.c_str());
//smPatykird1[i-1]->WillBeAnimated();
}
}
else if (str==AnsiString("animconrodprefix:"))
{//prefiks korbowodów - na razie używamy modeli pantografów
str=Parser->GetNextSymbol();
for (int i=1;i<=2;i++)
{
//asAnimName=str+i;
//smPatykirg1[i-1]=mdModel->GetFromName(asAnimName.c_str());
//smPatykirg1[i-1]->WillBeAnimated();
}
}
else if (str==AnsiString("pistonfactors:"))
{//Ra: parametry silnika parowego (tłoka)
/* //Ra: tymczasowo wyłączone ze względu na porządkowanie animacji pantografów
pant1x=Parser->GetNextSymbol().ToDouble(); //kąt przesunięcia dla pierwszego tłoka
pant2x=Parser->GetNextSymbol().ToDouble(); //kąt przesunięcia dla drugiego tłoka
panty=Parser->GetNextSymbol().ToDouble(); //długość korby (r)
panth=Parser->GetNextSymbol().ToDouble(); //długoś korbowodu (k)
*/
MoverParameters->EnginePowerSource.PowerType=SteamPower; //Ra: po chamsku, ale z CHK nie działa
}
else if (str==AnsiString("animreturnprefix:"))
{//prefiks drążka mimośrodowego - na razie używamy modeli pantografów
str=Parser->GetNextSymbol();
for (int i=1;i<=2;i++)
{
//asAnimName=str+i;
//smPatykird2[i-1]=mdModel->GetFromName(asAnimName.c_str());
//smPatykird2[i-1]->WillBeAnimated();
}
}
else if (str==AnsiString("animexplinkprefix:")) //animreturnprefix:
{//prefiks jarzma - na razie używamy modeli pantografów
str=Parser->GetNextSymbol();
for (int i=1;i<=2;i++)
{
//asAnimName=str+i;
//smPatykirg2[i-1]=mdModel->GetFromName(asAnimName.c_str());
//smPatykirg2[i-1]->WillBeAnimated();
}
}
else if (str==AnsiString("animpendulumprefix:"))
{//prefiks wahaczy
str=Parser->GetNextSymbol();
asAnimName="";
for (int i=1; i<=4; i++)
{//McZapkie-050402: wyszukiwanie max 4 wahaczy o nazwie str*
asAnimName=str+AnsiString(i);
smWahacze[i-1]=mdModel->GetFromName(asAnimName.c_str());
smWahacze[i-1]->WillBeAnimated();
}
str=Parser->GetNextSymbol().LowerCase();
if (str==AnsiString("pendulumamplitude:"))
fWahaczeAmp=Parser->GetNextSymbol().ToDouble();
}
else
if (str==AnsiString("engineer:"))
{//nazwa submodelu maszynisty
str=Parser->GetNextSymbol();
smMechanik0=mdModel->GetFromName(str.c_str());
if (!smMechanik0)
{//jak nie ma bez numerka, to może jest z numerkiem?
smMechanik0=mdModel->GetFromName(AnsiString(str+"1").c_str());
smMechanik1=mdModel->GetFromName(AnsiString(str+"2").c_str());
}
//aby dało się go obracać, musi mieć włączoną animację w T3D!
//if (!smMechanik1) //jeśli drugiego nie ma
// if (smMechanik0) //a jest pierwszy
// smMechanik0->WillBeAnimated(); //to będziemy go obracać
}
else if (str==AnsiString("animdoorprefix:"))
{//nazwa animowanych drzwi
int i,j,k,m;
str=Parser->GetNextSymbol();
for (i=0,j=0;i<ANIM_DOORS;++i)
j+=iAnimType[i]; //zliczanie wcześniejszych animacji
for (i=0;i<iAnimType[ANIM_DOORS];++i) //liczba drzwi
{//NBMX wrzesien 2003: wyszukiwanie drzwi o nazwie str*
asAnimName=str+AnsiString(i+1);
pAnimations[i+j].smAnimated=mdModel->GetFromName(asAnimName.c_str()); //ustalenie submodelu
if (pAnimations[i+j].smAnimated)
{//++iAnimatedDoors;
pAnimations[i+j].smAnimated->WillBeAnimated(); //wyłączenie optymalizacji transformu
switch (MoverParameters->DoorOpenMethod)
{//od razu zapinamy potrzebny typ animacji
case 1: pAnimations[i+j].yUpdate=UpdateDoorTranslate; break;
case 2: pAnimations[i+j].yUpdate=UpdateDoorRotate; break;
case 3: pAnimations[i+j].yUpdate=UpdateDoorFold; break; //obrót 3 kolejnych submodeli
}
pAnimations[i+j].iNumber=i; //parzyste działają inaczej niż nieparzyste
pAnimations[i+j].fMaxDist=300*300; //drzwi to z daleka widać
pAnimations[i+j].fSpeed=random(150); //oryginalny koncept z DoorSpeedFactor
pAnimations[i+j].fSpeed=(pAnimations[i+j].fSpeed+100)/100;
//Ra: te współczynniki są bez sensu, bo modyfikują wektor przesunięcia
}
}
}
}
}
else
if (str==AnsiString("sounds:")) //dzwieki
while (!Parser->EndOfFile && str!=AnsiString("endsounds"))
{
str= Parser->GetNextSymbol().LowerCase();
if (str==AnsiString("wheel_clatter:")) //polozenia osi w/m srodka pojazdu
{
dSDist=Parser->GetNextSymbol().ToDouble();
for (int i=0; i<iAxles; i++)
{
str=Parser->GetNextSymbol();
dWheelsPosition[i]=str.ToDouble();
str= Parser->GetNextSymbol().LowerCase();
if (str!=AnsiString("end"))
rsStukot[i].Init(str.c_str(),dSDist,GetPosition().x,GetPosition().y+dWheelsPosition[i],GetPosition().z,true);
}
if (str!=AnsiString("end"))
str= Parser->GetNextSymbol();
}
else
if ((str==AnsiString("engine:")) && (MoverParameters->Power>0)) //plik z dzwiekiem silnika, mnozniki i ofsety amp. i czest.
{
str= Parser->GetNextSymbol();
rsSilnik.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true,true);
if (rsSilnik.GetWaveTime()==0)
ErrorLog("Missed sound: \""+str+"\" for "+asFileName);
if (MoverParameters->EngineType==DieselEngine)
rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power+MoverParameters->nmax*60);
else if (MoverParameters->EngineType==DieselElectric)
rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power*3);
else
rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power+MoverParameters->nmax*60+MoverParameters->Power+MoverParameters->Power);
rsSilnik.AA=Parser->GetNextSymbol().ToDouble();
rsSilnik.FM=Parser->GetNextSymbol().ToDouble();//MoverParameters->nmax;
rsSilnik.FA=Parser->GetNextSymbol().ToDouble();
}
else
if (((str==AnsiString("ventilator:")) && ((MoverParameters->EngineType==ElectricSeriesMotor)||(MoverParameters->EngineType==ElectricInductionMotor)))) //plik z dzwiekiem wentylatora, mnozniki i ofsety amp. i czest.
{
str= Parser->GetNextSymbol();
rsWentylator.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true,true);
rsWentylator.AM=Parser->GetNextSymbol().ToDouble()/MoverParameters->RVentnmax;
rsWentylator.AA=Parser->GetNextSymbol().ToDouble();
rsWentylator.FM=Parser->GetNextSymbol().ToDouble()/MoverParameters->RVentnmax;
rsWentylator.FA=Parser->GetNextSymbol().ToDouble();
}
else
if ((str==AnsiString("transmission:")) && (MoverParameters->EngineType==ElectricSeriesMotor)) //plik z dzwiekiem, mnozniki i ofsety amp. i czest.
{
str= Parser->GetNextSymbol();
rsPrzekladnia.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rsPrzekladnia.AM=0.029;
rsPrzekladnia.AA=0.1;
rsPrzekladnia.FM=0.005;
rsPrzekladnia.FA=1.0;
}
else
if (str==AnsiString("brake:")) //plik z piskiem hamulca, mnozniki i ofsety amplitudy.
{
str= Parser->GetNextSymbol();
rsPisk.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rsPisk.AM=Parser->GetNextSymbol().ToDouble();
rsPisk.AA=Parser->GetNextSymbol().ToDouble()*(105-random(10))/100;
rsPisk.FM=1.0;
rsPisk.FA=0.0;
}
else
if (str==AnsiString("brakeacc:")) //plik z przyspieszaczem (upust po zlapaniu hamowania)
{
str= Parser->GetNextSymbol();
// sBrakeAcc.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
sBrakeAcc=TSoundsManager::GetFromName(str.c_str(),true);
bBrakeAcc=true;
// sBrakeAcc.AM=1.0;
// sBrakeAcc.AA=0.0;
// sBrakeAcc.FM=1.0;
// sBrakeAcc.FA=0.0;
}
else
if (str==AnsiString("unbrake:")) //plik z piskiem hamulca, mnozniki i ofsety amplitudy.
{
str= Parser->GetNextSymbol();
rsUnbrake.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rsUnbrake.AM=1.0;
rsUnbrake.AA=0.0;
rsUnbrake.FM=1.0;
rsUnbrake.FA=0.0;
}
else
if (str==AnsiString("derail:")) //dzwiek przy wykolejeniu
{
str= Parser->GetNextSymbol();
rsDerailment.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rsDerailment.AM=1.0;
rsDerailment.AA=0.0;
rsDerailment.FM=1.0;
rsDerailment.FA=0.0;
}
else
if (str==AnsiString("dieselinc:")) //dzwiek przy wlazeniu na obroty woodwarda
{
str= Parser->GetNextSymbol();
rsDiesielInc.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rsDiesielInc.AM=1.0;
rsDiesielInc.AA=0.0;
rsDiesielInc.FM=1.0;
rsDiesielInc.FA=0.0;
}
else
if (str==AnsiString("curve:"))
{
str= Parser->GetNextSymbol();
rscurve.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true);
rscurve.AM=1.0;
rscurve.AA=0.0;
rscurve.FM=1.0;
rscurve.FA=0.0;
}
else
if (str==AnsiString("horn1:")) //pliki z trabieniem
{
sHorn1.Load(Parser,GetPosition());
}
if (str==AnsiString("horn2:")) //pliki z trabieniem wysokoton.
{
sHorn2.Load(Parser,GetPosition());
if (iHornWarning) iHornWarning=2; //numer syreny do użycia po otrzymaniu sygnału do jazdy
}
if (str==AnsiString("departuresignal:")) //pliki z sygnalem odjazdu
{
sDepartureSignal.Load(Parser,GetPosition());
}
if (str==AnsiString("pantographup:")) //pliki dzwiekow pantografow
{
str=Parser->GetNextSymbol();
sPantUp.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true);
sPantUp.AM=50000;
sPantUp.AA=-1*(105-random(10))/100;
sPantUp.FM=1.0;
sPantUp.FA=0.0;
}
if (str==AnsiString("pantographdown:")) //pliki dzwiekow pantografow
{
str= Parser->GetNextSymbol();
sPantDown.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true);
sPantDown.AM=50000;
sPantDown.AA=-1*(105-random(10))/100;
sPantDown.FM=1.0;
sPantDown.FA=0.0;
}
else if (str==AnsiString("compressor:")) //pliki ze sprezarka
{
sCompressor.Load(Parser,GetPosition());
}
else if (str==AnsiString("converter:")) //pliki z przetwornica
{
//if (MoverParameters->EngineType==DieselElectric) //będzie modulowany?
sConverter.Load(Parser,GetPosition());
}
else if (str==AnsiString("turbo:")) //pliki z turbogeneratorem
{
sTurbo.Load(Parser,GetPosition());
}
else if (str==AnsiString("small-compressor:")) //pliki z przetwornica
{
sSmallCompressor.Load(Parser,GetPosition());
}
else if (str==AnsiString("dooropen:"))
{
str=Parser->GetNextSymbol();
rsDoorOpen.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true);
rsDoorOpen.AM=50000;
rsDoorOpen.AA=-1*(105-random(10))/100;
rsDoorOpen.FM=1.0;
rsDoorOpen.FA=0.0;
}
else if (str==AnsiString("doorclose:"))
{
str=Parser->GetNextSymbol();
rsDoorClose.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true);
rsDoorClose.AM=50000;
rsDoorClose.AA=-1*(105-random(10))/100;
rsDoorClose.FM=1.0;
rsDoorClose.FA=0.0;
}
}
else
if (str==AnsiString("internaldata:")) //dalej nie czytaj
{while (!Parser->EndOfFile)
{//zbieranie informacji o kabinach
str=Parser->GetNextSymbol().LowerCase();
if (str=="cab0model:")
{str=Parser->GetNextSymbol();
if (str!="none") iCabs=2;
}
else if (str=="cab1model:")
{str=Parser->GetNextSymbol();
if (str!="none") iCabs=1;
}
else if (str=="cab2model:")
{str=Parser->GetNextSymbol();
if (str!="none") iCabs=4;
}
}
Stop_InternalData=true;
}
}
//ABu 050205 - tego wczesniej nie bylo i uciekala pamiec:
delete Parser;
if (mdModel) mdModel->Init(); //obrócenie modelu oraz optymalizacja, również zapisanie binarnego
if (mdLoad) mdLoad->Init();
if (mdPrzedsionek) mdPrzedsionek->Init();
if (mdLowPolyInt) mdLowPolyInt->Init();
//sHorn2.CopyIfEmpty(sHorn1); //żeby jednak trąbił też drugim
Global::asCurrentTexturePath=AnsiString(szTexturePath); //kiedyś uproszczone wnętrze mieszało tekstury nieba
}
//---------------------------------------------------------------------------
void __fastcall TDynamicObject::RadioStop()
{//zatrzymanie pojazdu
if (Mechanik) //o ile ktoś go prowadzi
if (MoverParameters->SecuritySystem.RadioStop) //jeśli pojazd ma RadioStop i jest on aktywny
Mechanik->PutCommand("Emergency_brake",1.0,1.0,&vPosition,stopRadio);
};
void __fastcall TDynamicObject::RaLightsSet(int head,int rear)
{//zapalenie świateł z przodu i z tyłu, zależne od kierunku pojazdu
if (!MoverParameters) return; //może tego nie być na początku
if (rear==2+32+64)
{//jeśli koniec pociągu, to trzeba ustalić, czy jest tam czynna lokomotywa
//EN57 może nie mieć końcówek od środka członu
if (MoverParameters->Power>1.0) //jeśli ma moc napędową
if (!MoverParameters->ActiveDir) //jeśli nie ma ustawionego kierunku
{//jeśli ma zarówno światła jak i końcówki, ustalić, czy jest w stanie aktywnym
//np. lokomotywa na zimno będzie mieć końcówki a nie światła
rear=64; //tablice blaszane
//trzeba to uzależnić od "załączenia baterii" w pojeździe
}
if (rear==2+32+64) //jeśli nadal obydwie możliwości
if (iInventory&(iDirection?0x2A:0x15)) //czy ma jakieś światła czerowone od danej strony
rear=2+32; //dwa światła czerwone
else
rear=64; //tablice blaszane
}
if (iDirection) //w zależności od kierunku pojazdu w składzie
{//jesli pojazd stoi sprzęgiem 0 w stronę czoła
if (head>=0) iLights[0]=head;
if (rear>=0) iLights[1]=rear;
}
else
{//jak jest odwrócony w składzie (-1), to zapalamy odwrotnie
if (head>=0) iLights[1]=head;
if (rear>=0) iLights[0]=rear;
}
};
int __fastcall TDynamicObject::DirectionSet(int d)
{//ustawienie kierunku w składzie (wykonuje AI)
iDirection=d>0?1:0; //d:1=zgodny,-1=przeciwny; iDirection:1=zgodny,0=przeciwny;
CouplCounter=20; //żeby normalnie skanować kolizje, to musi ruszyć z miejsca
if (MyTrack)
{//podczas wczytywania wstawiane jest AI, ale może jeszcze nie być toru
//AI ustawi kierunek ponownie po uruchomieniu silnika
if (iDirection) //jeśli w kierunku Coupler 0
{if (MoverParameters->Couplers[0].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego?
ABuScanObjects(1,300); //szukanie czegoś do podłączenia
}
else
if (MoverParameters->Couplers[1].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego?
ABuScanObjects(-1,300);
}
return 1-(iDirection?NextConnectedNo:PrevConnectedNo); //informacja o położeniu następnego
};
TDynamicObject* __fastcall TDynamicObject::PrevAny()
{//wskaźnik na poprzedni, nawet wirtualny
return iDirection?PrevConnected:NextConnected;
};
TDynamicObject* __fastcall TDynamicObject::Prev()
{
if (MoverParameters->Couplers[iDirection^1].CouplingFlag)
return iDirection?PrevConnected:NextConnected;
return NULL; //gdy sprzęg wirtualny, to jakby nic nie było
};
TDynamicObject* __fastcall TDynamicObject::Next()
{
if (MoverParameters->Couplers[iDirection].CouplingFlag)
return iDirection?NextConnected:PrevConnected;
return NULL; //gdy sprzęg wirtualny, to jakby nic nie było
};
TDynamicObject* __fastcall TDynamicObject::NextC(int C)
{
if (MoverParameters->Couplers[iDirection].CouplingFlag&C)
return iDirection?NextConnected:PrevConnected;
return NULL; //gdy sprzęg inny, to jakby nic nie było
};
double __fastcall TDynamicObject::NextDistance(double d)
{//ustalenie odległości do następnego pojazdu, potrzebne do wstecznego skanowania
if (!MoverParameters->Couplers[iDirection].Connected)
return d; //jeśli nic nie ma, zwrócenie domyślnej wartości
if ((d<=0.0)||(MoverParameters->Couplers[iDirection].CoupleDist<d))
return MoverParameters->Couplers[iDirection].Dist;
else
return d;
};
TDynamicObject* __fastcall TDynamicObject::Neightbour(int &dir)
{//ustalenie następnego (1) albo poprzedniego (0) w składzie bez względu na prawidłowość iDirection
int d=dir; //zapamiętanie kierunku
dir=1-(dir?NextConnectedNo:PrevConnectedNo); //nowa wartość
return (d?(MoverParameters->Couplers[1].CouplingFlag?NextConnected:NULL):(MoverParameters->Couplers[0].CouplingFlag?PrevConnected:NULL));
};
void __fastcall TDynamicObject::CoupleDist()
{//obliczenie odległości sprzęgów
if (MyTrack?(MyTrack->iCategoryFlag&1):true) //jeśli nie ma przypisanego toru, to liczyć jak dla kolei
{//jeśli jedzie po szynach (również unimog), liczenie kul wystarczy
MoverParameters->SetCoupleDist();
}
else
{//na drodze trzeba uwzględnić wektory ruchu
double d0=MoverParameters->Couplers[0].CoupleDist;
//double d1=MoverParameters->Couplers[1].CoupleDist; //sprzęg z tyłu samochodu można olać, dopóki nie jeździ na wstecznym
vector3 p1,p2;
double d,w; //dopuszczalny dystans w poprzek
MoverParameters->SetCoupleDist(); //liczenie standardowe
if (MoverParameters->Couplers[0].Connected) //jeśli cokolwiek podłączone
if (MoverParameters->Couplers[0].CouplingFlag==0) //jeśli wirtualny
if (MoverParameters->Couplers[0].CoupleDist<300.0) //i mniej niż 300m
{//przez MoverParameters->Couplers[0].Connected nie da się dostać do DynObj, stąd prowizorka
//WriteLog("Collision of "+AnsiString(MoverParameters->Couplers[0].CoupleDist)+"m detected by "+asName+":0.");
w=0.5*(MoverParameters->Couplers[0].Connected->Dim.W+MoverParameters->Dim.W); //minimalna odległość minięcia
d=-DotProduct(vLeft,vCoulpler[0]); //odległość prostej ruchu od początku układu współrzędnych
d=fabs(DotProduct(vLeft,((TMoverParameters*)(MoverParameters->Couplers[0].Connected))->vCoulpler[MoverParameters->Couplers[0].ConnectedNr])+d);
//WriteLog("Distance "+AnsiString(d)+"m from "+asName+":0.");
if (d>w)
MoverParameters->Couplers[0].CoupleDist=(d0<10?50:d0); //przywrócenie poprzedniej
}
if (MoverParameters->Couplers[1].Connected) //jeśli cokolwiek podłączone
if (MoverParameters->Couplers[1].CouplingFlag==0) //jeśli wirtualny
if (MoverParameters->Couplers[1].CoupleDist<300.0) //i mniej niż 300m
{
//WriteLog("Collision of "+AnsiString(MoverParameters->Couplers[1].CoupleDist)+"m detected by "+asName+":1.");
w=0.5*(MoverParameters->Couplers[1].Connected->Dim.W+MoverParameters->Dim.W); //minimalna odległość minięcia
d=-DotProduct(vLeft,vCoulpler[1]); //odległość prostej ruchu od początku układu współrzędnych
d=fabs(DotProduct(vLeft,((TMoverParameters*)(MoverParameters->Couplers[1].Connected))->vCoulpler[MoverParameters->Couplers[1].ConnectedNr])+d);
//WriteLog("Distance "+AnsiString(d)+"m from "+asName+":1.");
if (d>w)
MoverParameters->Couplers[0].CoupleDist=(d0<10?50:d0); //przywrócenie poprzedniej
}
}
};
TDynamicObject* __fastcall TDynamicObject::ControlledFind()
{//taka proteza: chcę podłączyć kabinę EN57 bezpośrednio z silnikowym, aby nie robić tego przez ukrotnienie
//drugi silnikowy i tak musi być ukrotniony, podobnie jak kolejna jednostka
//lepiej by było przesyłać komendy sterowania, co jednak wymaga przebudowy transmisji komend (LD)
//problem się robi ze światłami, które będą zapalane w silnikowym, ale muszą świecić się w rozrządczych
//dla EZT światłą czołowe będą "zapalane w silnikowym", ale widziane z rozrządczych
//również wczytywanie MMD powinno dotyczyć aktualnego członu
//problematyczna może być kwestia wybranej kabiny (w silnikowym...)
//jeśli silnikowy będzie zapięty odwrotnie (tzn. -1), to i tak powinno jeździć dobrze
//również hamowanie wykonuje się zaworem w członie, a nie w silnikowym...
TDynamicObject *d=this; //zaczynamy od aktualnego
if (d->MoverParameters->TrainType&dt_EZT) //na razie dotyczy to EZT
if (d->NextConnected?d->MoverParameters->Couplers[1].AllowedFlag&ctrain_depot:false)
{//gdy jest człon od sprzęgu 1, a sprzęg łączony warsztatowo (powiedzmy)
if ((d->MoverParameters->Power<1.0)&&(d->NextConnected->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma
d=d->NextConnected; //będziemy sterować tym z mocą
}
else if (d->PrevConnected?d->MoverParameters->Couplers[0].AllowedFlag&ctrain_depot:false)
{//gdy jest człon od sprzęgu 0, a sprzęg łączony warsztatowo (powiedzmy)
if ((d->MoverParameters->Power<1.0)&&(d->PrevConnected->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma
d=d->PrevConnected; //będziemy sterować tym z mocą
}
return d;
};
//---------------------------------------------------------------------------
void __fastcall TDynamicObject::ParamSet(int what,int into)
{//ustawienie lokalnego parametru (what) na stan (into)
switch (what&0xFF00)
{
case 0x0100: //to np. są drzwi, bity 0..7 określają numer 1..254 albo maskę dla 8 różnych
if (what&1) //na razie mamy lewe oraz prawe, czyli używamy maskę 1=lewe, 2=prawe, 3=wszystkie
if (MoverParameters->DoorLeftOpened)
{//są otwarte
if (!into) //jeśli zamykanie
{
//dźwięk zamykania
}
}
else
{//są zamknięte
if (into) //jeśli otwieranie
{
//dźwięk otwierania
}
}
if (what&2) //prawe działają niezależnie od lewych
if (MoverParameters->DoorRightOpened)
{//są otwarte
if (!into) //jeśli zamykanie
{
//dźwięk zamykania
}
}
else
{//są zamknięte
if (into) //jeśli otwieranie
{
//dźwięk otwierania
}
}
break;
}
};
int __fastcall TDynamicObject::RouteWish(TTrack *tr)
{//zapytanie do AI, po którym segmencie (-6..6) jechać na skrzyżowaniu (tr)
return Mechanik?Mechanik->CrossRoute(tr):0; //wg AI albo prosto
};
AnsiString __fastcall TDynamicObject::TextureTest(AnsiString &name)
{//Ra 2015-01: sprawdzenie dostępności tekstury o podanej nazwie
AnsiString x=name+".dds"; //na razie prymitywnie
if (FileExists(x))
return x;
else
{x=name+".tga"; //w zasadzie to należałoby uwzględnić deklarowaną kolejność
if (FileExists(x))
return x;
else
{x=name+".bmp";
if (FileExists(x))
return x;
}
}
return ""; //nie znaleziona
};
void __fastcall TDynamicObject::DestinationSet(AnsiString to)
{//ustawienie stacji docelowej oraz wymiennej tekstury 4, jeśli istnieje plik
//w zasadzie, to każdy wagon mógłby mieć inną stację docelową
//zwłaszcza w towarowych, pod kątem zautomatyzowania maewrów albo pracy górki
//ale to jeszcze potrwa, zanim będzie możliwe, na razie można wpisać stację z rozkładu
if (abs(iMultiTex)>=4) return; //jak są 4 tekstury wymienne, to nie zmieniać rozkładem
asDestination=to;
to=Global::Bezogonkow(to); //do szukania pliku obcinamy ogonki
AnsiString x;
if (to.IsEmpty()) to="nowhere";
x=TextureTest(asBaseDir+to+"@"+MoverParameters->TypeName); //w pierwszej kolejności z nazwą FIZ/MMD
if (!x.IsEmpty())
{
ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,x.c_str(),9); //rozmywania 0,1,4,5 nie nadają się
return;
}
x=TextureTest(asBaseDir+to); //na razie prymitywnie
if (!x.IsEmpty())
ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,x.c_str(),9); //rozmywania 0,1,4,5 nie nadają się
else
ReplacableSkinID[4]=0; //0 to brak? -1 odpada, bo inaczej się będzie mapować
//Ra 2015-01: żeby zalogować błąd, trzeba by mieć pewność, że model używa tekstury nr 4
};
void __fastcall TDynamicObject::OverheadTrack(float o)
{//ewentualne wymuszanie jazdy bezprądowej z powodu informacji w torze
if (ctOwner) //jeśli ma obiekt nadzorujący
{//trzeba zaktualizować mapę flag bitowych jazdy bezprądowej
if (o<0.0)
{//normalna jazda po tym torze
ctOwner->iOverheadZero&=~iOverheadMask; //zerowanie bitu - może pobierać prąd
ctOwner->iOverheadDown&=~iOverheadMask; //zerowanie bitu - może podnieść pantograf
}
else if (o>0.0)
{//opuszczenie pantografów
ctOwner->iOverheadZero|=iOverheadMask; //ustawienie bitu - ma jechać bez pobierania prądu
ctOwner->iOverheadDown|=iOverheadMask; //ustawienie bitu - ma opuścić pantograf
}
else
{//jazda bezprądowa z podniesionym pantografem
ctOwner->iOverheadZero|=iOverheadMask; //ustawienie bitu - ma jechać bez pobierania prądu
ctOwner->iOverheadDown&=~iOverheadMask; //zerowanie bitu - może podnieść pantograf
}
}
};
Reference in New Issue View Git Blame Copy Permalink