1:

if Seg.SType = TR_STR then                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

//==========================================================================*
// Main Car Data record
//--------------------------------------------------------------------------*
  TCarElt = packed record                       // car.h
    Index: Int;         // car index
    Info: TInitCar;     // public
    Pub: TPublicCar;    // public
{$IFDEF TORCS_V1.3.0}
    Dummy1: Int;
{$ELSE}
    Dummy1: Int;
{$ENDIF}
    Race: TCarRaceInfo; // public
    Priv: TPrivCar;     // private
    Ctrl: TCarCtrl;     // private
    PitCmd: TCarPitCmd; // private
    Robot: PRobotItf;   // private
    Next: PCarElt;      // Next in List
    Dummy2: Int;
  end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:

type 
  TIPCCarData = class
  private
    // >>> Instanzlokaler Datenbereich:
    oTORCSIndex: Int;                            // Index des Wagens
//>>>  oTORCSInfo: TInitCar;                        // Infos zum Wagen
    oInfoName: TTorcsName;                       // Driver's name
{$IFDEF TORCS_V1.3.0}
    oInfoTeamName: TTorcsName;                   // Team name
{$ENDIF}
    oInfoCarName: TTorcsName;                    // Car's object name
    oInfoCategory: TTorcsName;                   // Car's category
    oInfoRaceNumber: Int;                        // Car's race number
    oInfoStartRank: Int;                         // Car's starting position
    oInfoDriverType: Int;                        // Driver type
    oInfoSkillLevel: Int;                        // Driver's skill level (0=rookie -> 3=pro)
    oInfoIconColorR: Tdble;                      // Car color in leaders board
    oInfoIconColorG: Tdble;                      // Car color in leaders board
    oInfoIconColorB: Tdble;                      // Car color in leaders board
    oInfoDimension: T3Dd;                        // Car's mesures
    oInfoDrvPos: T3Dd;                           // Driver's position
    oInfoBonnetPos: T3Dd;                        // Bonnet's position
    oInfoTank: Tdble;                            // Fuel tank capacity
    oInfoSteerLock: Tdble;                       // Steer lock angle
    oInfoStatGC: T3Dd;                           // Static pos of GC (should be the origin of car axis)
    oInfoWheel: array [0..3] of TWheelSpec;      // Wheels specifications
    oInfoVisualAttr: tVisualAttributes;          // Visual attributes
//<<<
//>>>  oTORCSPub: TPublicCar;
    oPubDynGC: TDynPt;                           // GC data (car axis)
    oPubDynGCg: TDynPt;                          // GC data (world axis)
    oPubPosMat: TSGMat4;                         // Position matrix
    oPubTrkPos: TTrkLocPos;                      // Current track position. The segment is the track segment (not sides)
    oPubState: Int;                              // State of the car.
    oPubCorner: array [0..3] of tPosd;
{$IFDEF TORCS_V1.3.0}
  oAlignmentDummy: Int;
{$ELSE}
  oAlignmentDummy: Int;
{$ENDIF}
//<<<
//>>>  oTORCSRace: TCarRaceInfo;
    oRaceBestLapTime: Double;
    oRaceDeltaBestLapTime: Double;
    oRaceCurLapTime: Double;
    oRaceLastLapTime: Double;
    oRaceCurTime: Double;
    oRaceTopSpeed: Tdble;
    oRaceLaps: Int;
    oRaceNbPitStops: Int;
    oRaceRemainingLaps: Int;
    oRacePos: Int;
    oRaceDummy1: Int;
    oRaceTimeBehindLeader: Double;
    oRaceLapsBehindLeader: Int;
    oRaceDummy2: Int;
    oRaceTimeBehindPrev: Double;
    oRaceTimeBeforeNext: Double;
    oRaceDistRaced: Tdble;
    oRaceDistFromStartLine: Tdble;
    oRaceScheduledEventTime: Double;
    oRacePit: PTrackOwnPit;
    oRaceEvent: Int;
    oRacePenaltyList: TCarPenaltyHead; // List of current penalties
//<<<
//>>>  oTORCSPriv: TPrivCar;
    oPrivParamsHandle: Pointer;                  // accessible parameters for modules
    oPrivCarHandle: Pointer;                     // parameters for car caracteristics
    oPrivDriverIndex: Int;                       // index when multiple drivers are in the same dll
    oPrivModName: TTorcsName;                    // dll name
    oPrivWheel: array [0..3] of TWheelState;
    oPrivCorner: array [0..3] of TPosd;          // car's corners position
    oPrivGear: Int;             // current gear
    oPrivFuel: Tdble;           // remaining fuel (liters)
    oPrivFuel_consumption_total: Tdble; // l
    oPrivFuel_consumption_instant: Tdble; // l/100km (>100 means infinity)
    oPrivEnginerpm: Tdble;
    oPrivEnginerpmRedLine: Tdble;
    oPrivEnginerpmMax: Tdble;
    oPrivEnginerpmMaxTq: Tdble;
    oPrivEnginerpmMaxPw: Tdble;
    oPrivEngineMaxTq: Tdble;
    oPrivEngineMaxPw: Tdble;
    oPrivGearRatio: array [0..MAX_GEARS - 1] of Tdble; // including final drive
    oPrivGearNb: Int;                     // incl reverse and neutral
    oPrivGearOffset: Int;                 // gearRatio[gear + gearOffset] is the ratio for gear
    oPrivSkid: array [0..3] of Tdble;     // skid intensity
    oPrivReaction: array [0..3] of Tdble; // reaction on wheels
    oPrivCollision: Int;
    oPrivSmoke: Tdble;
    oPrivNormal: T3Dd;
    oPrivCollpos: T3Dd; // Collision position, useful for sound
    oPrivDammage: Int;
    oPrivDebug: Int;
    oPrivCollision_state: TCollisionState; // collision state
//<<<
    // Der Rest muss über den Zeiger gehen, da es sich ab hier um
    // Information an TORCS handelt
    oTORCSCtrl: TCarCtrl;
    oTORCSPitCmd: TCarPitCmd;

    // Noch Instanzlokaler Datenbereich:
    oRobot: TRobotItf;
    // <<< Ende Instanzlokaler Datenbereich!                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:

Turbo Delphi 2006:
TOCRS Alignment Check: (Ohne Änderungen)

Offset(oIndex) : 0000 0000
Offset(oInfo)  : 0004 0004
Offset(oPub)   : 0328 0328
Offset(oRace)  : 0664 0664
Offset(Priv)   : 0792 0792
Offset(oCtrl)  : 1444 1444
Offset(oPitCmd): 1616 1616
Offset(oRobot) : 1628 1628
SizeOf(Index)       : 0004
SizeOf(TInitCar)    : 0324
SizeOf(TPublicCar)  : 0332
SizeOf(TCarRaceInfo): 0128
SizeOf(TPrivCar)    : 0652
SizeOf(TCarCtrl)    : 0172
SizeOf(TCarPitCmd)  : 0012
SizeOf(TRobotItf)   : 0028
SizeOf(TCarElt)     : 1640

Delphi 5:
TOCRS Alignment Check: (Ohne Änderungen an den Recorddefinitionen in UnitTorcsTypes)

Offset(oIndex) : 0000 0000
Offset(oInfo)  : 0004 0004
Offset(oPub)   : 0328 0328
Offset(oRace)  : 0668 0664 < Fehler im Objekt TIPCCarData (UnitTorcsData)
Offset(Priv)   : 0796 0792
Offset(oCtrl)  : 1448 1444
Offset(oPitCmd): 1620 1616
Offset(oRobot) : 1632 1628
SizeOf(Index)       : 0004
SizeOf(TInitCar)    : 0324
SizeOf(TPublicCar)  : 0332
SizeOf(TCarRaceInfo): 0128
SizeOf(TPrivCar)    : 0652
SizeOf(TCarCtrl)    : 0172
SizeOf(TCarPitCmd)  : 0012
SizeOf(TRobotItf)   : 0028
SizeOf(TCarElt)     : 1640                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

type 
  TIPCCarData = class
  private
//>>>+++ Änderung für D5 und D7?:
    // Achtung: 
    // Um die Ausrichtung der Daten im Speicher für die Delphi-Versionen
    // 5 und 7? TORCS-Kompatibel zu erreichen ist hier der AlignmentOffset
    // nötig! 
    oAlignmentOffset: Int;                       // Für D5 und D7?
//<<<+++
    // >>> Instanzlokaler Datenbereich:
    oTORCSIndex: Int;                            // Index des Wagens
    ...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

Delphi 5: mit AlignmentOffset!
TOCRS Alignment Check: (Ohne Änderungen an den Recorddefinitionen in UnitTorcsTypes)

Offset(oIndex) : 0000 0000
Offset(oInfo)  : 0004 0004
Offset(oPub)   : 0328 0328
Offset(oRace)  : 0664 0664
Offset(Priv)   : 0792 0792
Offset(oCtrl)  : 1444 1444
Offset(oPitCmd): 1616 1616
Offset(oRobot) : 1628 1628
SizeOf(Index)       : 0004
SizeOf(TInitCar)    : 0324
SizeOf(TPublicCar)  : 0332
SizeOf(TCarRaceInfo): 0128
SizeOf(TPrivCar)    : 0652
SizeOf(TCarCtrl)    : 0172
SizeOf(TCarPitCmd)  : 0012
SizeOf(TRobotItf)   : 0028
SizeOf(TCarElt)     : 1640                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

{$IFDEF TORCS_V1.3.0}
  FuellBytes := oAlignmentDummy;                 // dito
  oAlignmentDummy := FuellBytes;                 // dito
  oAlignmentOffset := 0;                         // dito
{$ELSE}
  FuellBytes := oAlignmentDummy;                 // dito
  oAlignmentDummy := FuellBytes;                 // dito
  oAlignmentOffset := 0;                         // dito
{$ENDIF}                    

1:

 if SteerCmd = 0.0 then                    

1:

 if Abs(SteerCmd) < Epsilon then                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

]
//==========================================================================*
// Reifenreibungskoeffizient
//--------------------------------------------------------------------------*
procedure TIPCCarData.InitTireMu;
var
  WheelSect: array [0..3] of PChar;
  Tm: Tdble;
  I: Int;
begin
  WheelSect[0] := SECT_FRNTRGTWHEEL;
  WheelSect[1] := SECT_FRNTLFTWHEEL;
  WheelSect[2] := SECT_REARRGTWHEEL;
  WheelSect[3] := SECT_REARLFTWHEEL;
  //Tendenz aufsteigendes Ergebnis
  {
  //Wähle kleinstes mue war bisher 
  TireMu := FLT_MAX;
  for I := 0 to 3 do
    TireMu := Min(TireMu, GfParmGetNum(GetCarHandle, WheelSect[I], PRM_MU, nil, 1.0));
  }
  {
  //Wähle harmonisches Mittel //mue  =0 gibt es hier nicht wegen 1/x
  Tm := 0;
  for I := 0 to 3 do
    Tm := Tm+1/GfParmGetNum(GetCarHandle, WheelSect[I], PRM_MU, nil, 1.0);
  TireMu := 4/Tm;
  }
  {
  //Wähle geometrisches Mittel
  Tm := 1;
  for I := 0 to 3 do
    Tm := Tm*GfParmGetNum(GetCarHandle, WheelSect[I], PRM_MU, nil, 1.0);
  TireMu := exp(ln(tm)/4);
  }

  //Wähle aritmetisches Mittel
  TireMu := 0;
  for I := 0 to 3 do
    TireMu := TireMu+GfParmGetNum(GetCarHandle, WheelSect[I], PRM_MU, nil, 1.0);
  TireMu := TireMu/4;

  {//Ist fast immer das schnellste erzeugt schlechte erste Runde ;-)
  //Wähle größtes mue
  TireMu := 0;
  for I := 0 to 3 do
    TireMu := Max(TireMu, GfParmGetNum(GetCarHandle, WheelSect[I], PRM_MU, nil, 1.0));
  }

end;                    

1:

    <attstr name="type" in="SPOOL,FREE,LIMITED SLIP" val="FREE"/>                    

1:

    <attnum name="tireinit" in="MIN,MEAN,MAX" val="MEAN"/>                    

1:
2:
3:
4:
5:
6:
7:

  ...
  BOTNAME_ATT_TIREINIT = 'tireinit';             // Art der Mittelung
  ...
  TireInit := GfParmGetStr(CarSettings
    , BOTNAME_PRIV, BOTNAME_ATT_TIREINIT, 'MIN');
  WriteLn(Format('oTireInit: %s',[TireInit]));
  ...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:

//==========================================================================*
// Reifenreibungskoeffizient
//--------------------------------------------------------------------------*
procedure TIPCCarData.InitTireMu;
var
  WheelSect: array [0..3] of PChar;
  Tm: Tdble;
  I: Int;
begin
  WheelSect[0] := SECT_FRNTRGTWHEEL;
  WheelSect[1] := SECT_FRNTLFTWHEEL;
  WheelSect[2] := SECT_REARRGTWHEEL;
  WheelSect[3] := SECT_REARLFTWHEEL;

  if oTireInitType = 2 then
  begin
    Tm := 0.0;
    for I := 0 to 3 do
      Tm := Max(Tm, GfParmGetNum(GetCarHandle
        , WheelSect[I], PRM_MU, nil, 1.0));

    TireMu := Tm;
  end
  else if oTireInitType = 1 then
  begin
    Tm := 0.0;
    for I := 0 to 3 do
      Tm := Tm + GfParmGetNum(GetCarHandle
        , WheelSect[I], PRM_MU, nil, 1.0);

    TireMu := Tm / 4;
  end
  else
  begin
    Tm := FLT_MAX;
    for I := 0 to 3 do
      Tm := Min(Tm, GfParmGetNum(GetCarHandle
        , WheelSect[I], PRM_MU, nil, 1.0));

    TireMu := Tm;
  end
end;
//==========================================================================*

//==========================================================================*
// Art der Mittelung ausgeben
//--------------------------------------------------------------------------*
function TIPCCarData.GetTireInit: string;
begin
  if oTireInitType = 1 then
    Result := 'MEAN'
  else if oTireInitType = 2 then
    Result := 'MAX'
  else
    Result := 'MIN';
end;
//==========================================================================*

//==========================================================================*
// Art der Mittelung einstellen
//--------------------------------------------------------------------------*
procedure TIPCCarData.SetTireInit(Value: string);
begin
  if UpperCase(Value) = 'MEAN' then
    oTireInitType := 1
  else if UpperCase(Value) = 'MAX' then
    oTireInitType := 2
  else
    oTireInitType := 0;
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:

        <section name="111">
          <attnum name="time" val="122.272"/>
          <attnum name="best lap time" val="122.272"/>
          <attnum name="top speed" val="76.3769"/>
          <attnum name="bottom speed" val="1.88825"/>
          <attnum name="dammages" val="0"/>
        </section>                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE params SYSTEM "C:/Programme/torcs/config/params.dtd">
<?xml-stylesheet type="text/xsl" href="file:///C:/Programme/torcs/config/style.xsl"?>

<params name="Results">
  <section name="Header">
    <attnum name="date" val="1.1698e+009"/>
  </section>

  <section name="Current">
    <attnum name="current track" val="1"/>
    <attnum name="current race" val="2"/>
    <attnum name="current driver" val="1"/>
  </section>

  <section name="hhr-track">
    <section name="Drivers">
      <section name="1">
        <attstr name="dll name" val="delphin"/>
        <attnum name="index" val="1"/>
      </section>

      <section name="2">
        <attstr name="dll name" val="berniw2"/>
        <attnum name="index" val="8"/>
      </section>

      <section name="3">
        <attstr name="dll name" val="bt"/>
        <attnum name="index" val="6"/>
      </section>

      <section name="4">
        <attstr name="dll name" val="bt"/>
        <attnum name="index" val="7"/>
      </section>

      <section name="5">
        <attstr name="dll name" val="inferno"/>
        <attnum name="index" val="4"/>
      </section>

    </section>

    <section name="Results">
      <section name="Qualifications">
        <section name="Rank">
          <section name="1">
            <attstr name="name" val="berniw two 8"/>
            <attstr name="car" val="Mercedes CLK DTM"/>
            <attnum name="best lap time" val="83.022"/>
            <attstr name="module" val="berniw2"/>
            <attnum name="idx" val="8"/>
            <attnum name="points" val="3"/>
          </section>

          <section name="2">
            <attstr name="name" val="bt 7"/>
            <attstr name="car" val="Mercedes CLK DTM"/>
            <attnum name="best lap time" val="84.292"/>
            <attstr name="module" val="bt"/>
            <attnum name="idx" val="6"/>
            <attnum name="points" val="2"/>
          </section>

          <section name="3">
            <attstr name="name" val="bt 8"/>
            <attstr name="car" val="Mercedes CLK DTM"/>
            <attnum name="best lap time" val="84.338"/>
            <attstr name="module" val="bt"/>
            <attnum name="idx" val="7"/>
            <attnum name="points" val="1"/>
          </section>

          <section name="4">
            <attstr name="name" val="delphin 1"/>
            <attstr name="car" val="Mercedes CLK DTM"/>
            <attnum name="best lap time" val="113.348"/>
            <attstr name="module" val="delphin"/>
            <attnum name="idx" val="1"/>
            <attnum name="points" val="0"/>
          </section>

          <section name="5">
            <attstr name="name" val="Inferno 4"/>
            <attstr name="car" val="Mercedes CLK DTM"/>
            <attnum name="best lap time" val="0"/>
            <attstr name="module" val="inferno"/>
            <attnum name="idx" val="4"/>
            <attnum name="points" val="0"/>
          </section>

        </section>

      </section>

    </section>

  </section>

  <section name="Standings">
    <section name="1">
      <attstr name="name" val="berniw two 8"/>
      <attstr name="module" val="berniw2"/>
      <attnum name="idx" val="8"/>
      <attnum name="points" val="3"/>
    </section>

    <section name="2">
      <attstr name="name" val="bt 7"/>
      <attstr name="module" val="bt"/>
      <attnum name="idx" val="6"/>
      <attnum name="points" val="2"/>
    </section>

    <section name="3">
      <attstr name="name" val="bt 8"/>
      <attstr name="module" val="bt"/>
      <attnum name="idx" val="7"/>
      <attnum name="points" val="1"/>
    </section>

    <section name="4">
      <attstr name="name" val="delphin 1"/>
      <attstr name="module" val="delphin"/>
      <attnum name="idx" val="1"/>
      <attnum name="points" val="0"/>
    </section>

    <section name="5">
      <attstr name="name" val="Inferno 4"/>
      <attstr name="module" val="inferno"/>
      <attnum name="idx" val="4"/>
      <attnum name="points" val="0"/>
    </section>

  </section>

</params>                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:

Y ist die Fahrrichtung in der X-Y -Ebene 
SecId    RadiusYZ   RadiusXY   Wurzel(ssq(SecId))
   91    0.000000 3.400E+0038  500.000000
   92    0.000000 3.400E+0038  467.824737
   93    0.000000 3.400E+0038  433.266625
   94    0.000000 3.400E+0038  395.701849
   95    0.000000 3.400E+0038  354.175010
   96    0.000000 3.400E+0038  307.082923
   97    0.000000 3.400E+0038  251.316394
   98    0.000000 3.400E+0038  178.941102
   99    0.000000   50.000000   29.663121
  100    0.000000   50.000000   29.663121
  101    0.000000   50.000000   29.663121
  102    0.000000   50.000000   29.663121
  103    0.000000   50.000000   29.663121
karma dort
1.633906
1.639396
1.652586
1.660683
1.671946
1.683223
1.692166
1.693305
1.701718
1.708459
1.713396
1.719500
1.720444
1.726402
1.732276
1.735018

Meine Brechnung von ssq-Werte mit Maximum von 120 m/s ohne Faltung
   91    0.000000 3.400E+0038  120.000000
   92    0.000000 3.400E+0038  120.000000
   93    0.000000 3.400E+0038  120.000000
   94    0.000000 3.400E+0038  120.000000
   95    0.000000 3.400E+0038  120.000000
   96    0.000000 3.400E+0038  120.000000
   97    0.000000 3.400E+0038  120.000000
   98    0.000000 3.400E+0038  120.000000
   99    0.000000   50.000000   35.592155  //ca 20% mehr
  100    0.000000   50.000000   35.592155
  101    0.000000   50.000000   35.592155
  102    0.000000   50.000000   35.592155
  103    0.000000   50.000000   35.592155
  104    0.000000   50.000000   35.592155
  105    0.000000   50.000000   35.592155
  106    0.000000   50.000000   35.592155
  107    0.000000   50.000000   35.592155
  108    0.000000   50.000000   35.592155                    

1:
2:
3:
4:
5:
6:
7:
8:

V12 := Sqr(SpeedX);
 {
  Factor := 0.5 / (LocalMu * G);
  //Bremsweg nur aus der Bremskraft des Eigengewichtes ohne Aerodynamik
  MaxLookAheadDistance := V12 * Factor;
 }
 MaxLookAheadDistance:= Brakedist(V12,LocalMu);
 // Der Gag bei kleinen Geschwindigkeiten ist BrakeDist > V12*Faktor ???????                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

Falls Sec[i].ssq>Sec[i+1].ssq dann
  begin
  aktssq := Sec[i+1].ssq;
  j :=i;
  deltaV2 := sqr(F(Car,Sec(j)));
  aktssq := Sec[i+1].ssq+DeltaV2;
  Solange Sec[j].ssq>aktssq 
    Sec[j].ssq:=aktssq; 
    deltaV2 := sqr(F(Car,Sec(j)));
    aktssq := aktssq+deltaV2
    dec(j)
  end;                    

1:

    else if (Distance > 0) and (Speed < 0.9 * MyCarData.Speed) then                    

1:

    else if (Distance > 0) and (Speed < MyCarData.Speed) then                    

1:

    else if (Distance > 0) and (Speed < 1.1 * MyCarData.Speed) then                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

//==========================================================================*
// HHR-Track: Korrekturen für Quadrat der maximal möglichen Geschwindigkeit
//--------------------------------------------------------------------------*
function TDriver.CalcHHRTrack(Sec: TSection; Value: Tdble): Tdble;
begin
  Result := Value;
  if (Sec.ID > 430) and (Sec.ID < 550) then // In beiden Fällen aktiviert
    Result := 1250 * Sec.SpeedSqrFactor
  else if (Sec.ID > 1500) and (Sec.ID < 1550) then //<<< Spitzkehre
    Result := 400 * Sec.SpeedSqrFactor;  // nur ohne Fkt. unten aktiviert!
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:

//==========================================================================*
// Spitzkehre nach der Parabolika
//--------------------------------------------------------------------------*
procedure Spitzkehre
  (TD: TTrackDescription; SecS1, SecS2, SecE1, SecE2: TSection);
var
  ...
begin
  // Tangente Anfahrtsgerade mit Offset von 7 m nach außen bestimmen
  P1 := Add(SecS1.Mid2D,Mult(-7,SecS1.Tor2D));
  P2 := Add(SecS2.Mid2D,Mult(-7,SecS2.Tor2D));
  TS := TStraight.Create                         // Tangente aus zwei Punkten
    (P1.X,P1.Y                                   // der Anfahrtsgeraden
    ,P2.X-P1.X                                   // berechnen
    ,P2.Y-P1.Y);

  // Tangente Abfahrtsgerade mit Offset von 7 m nach außen bestimmen
  P1 := Add(SecE1.Mid2D,Mult(-7,SecE1.Tor2D));
  P2 := Add(SecE2.Mid2D,Mult(-7,SecE2.Tor2D));
  TE := TStraight.Create                         // Tangente aus zwei Punkten
    (P1.X,P1.Y                                   // der Abfahrtsgeraden
    ,P2.X-P1.X                                   // berechnen
    ,P2.Y-P1.Y);

  // Tangenten-Schnittpunkt bestimmen
  T := TS.Intersect(TE);

  // Tangenten-Schnittwinkel bestimmen
  Beta := ArcCos(TS.Angle(TE));

  // Zwangspunkt bestimmen (Scheitel der Kurve)
  Q := MinDist(TD,T,SecS2,SecE1,Ind);

  // Abstand des Zwangspunkts vom Tangentenschnittpunkt bestimmen
  TQ := Dist(T,Q);

  // Abstand des Zwangspunkts von Anfahrtstangente bestimmen
  Y := TS.Dist(Q);

  // Station des Zwangspunkts auf Anfahrtstangente bestimmen
  TAs := Sqrt(TQ * TQ - Y * Y);

  // Abstand des Punktes A auf der Anfahrtstangente von T bestimmen
  // Bei A beginnt der Kreisbogen
  Tgbh := tan(Beta / 2.0);
  YTgbh := Y * Tgbh;
  X := YTgbh + Sqrt(YTgbh*YTgbh +  2 * TAs * YTgbh - Y*Y);
  TA := TAs + X;

  // Radius bestimmen
  R := TA * tgbh;

  // Kontrolle:
  X2 := R*R - (R-Y)*(R-Y);
  if Abs(X2 - (X*X)) > 0.01 then
    WriteLn(Format('?: %.3f² = %.3f <> %.3f',[X, X*X, X2]));

  // Kreismittelpunkt schätzen
  DTQ := Normalize(Sub(Q,T));
  M := Add(T,Mult(R+TQ,DTQ));

  // Offsets der Sections bestimmen
  // 1. Kreisbogen vom Scheitel zurück bis etwa zum Punkt A
  Offset := FLT_MAX;
  Sec := TD[Ind];                                // Segment d. Zwangspunktes
  repeat
    LastOffset := Sec.Offset;
    Sec := TD[TD.Loop(Sec.ID - 1)];              // Vorangegangenes Segment
    Sec.Offset := NewOffset(Sec,M,R);
    if Offset > Sec.Offset then
      Offset := Sec.Offset;
  until (Sec = SecS2) or (Offset < Sec.Offset);
  Offset := Sec.Offset;

  // 2. Übergang zurück
  oP[0].X := 0.0;
  oP[0].Y := SecS1.Offset;
  oP[0].S := 0.0;
  oP[1].X := 60.0;
  oP[1].Y := -7;
  oP[1].S := 0.0;
  oP[2].X := 70.0;
  oP[2].Y := Offset;
  oP[2].S := 0.0;
  oP[3].X := 71.0;
  oP[3].Y := LastOffset;
  oP[3].S := 0.0;

  oOrdinate := TSplineOrdinate.Create;
  oOrdinate.Count := 4;
  oOrdinate.Points := Addr(oP);

  Delta := 70;
  repeat
    Sec := TD[TD.Loop(Sec.ID - 1)];              // Vorangegangenes Segment
    Delta := Delta - 1.0;
    Sec.Offset := oOrdinate.Evaluate(Delta);
  until Delta <= 0.0;
  oOrdinate.Free;

  // 3. Kreisbogen vom Scheitel vorwärts
  Offset := FLT_MAX;
  Sec := TD[Ind];                                // Segment d. Zwangspunktes
  repeat
    Sec := TD[TD.Loop(Sec.ID + 1)];              // Folgendes Segment
    Sec.Offset := NewOffset(Sec,M,R);
    if Offset > Sec.Offset then
      Offset := Sec.Offset;
  until (Sec = SecE1) or (Offset < Sec.Offset);
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

Original:
begin
  AllowedSpeed := GetAllowedSpeed(oCurrSec);
  //Gib Vollgas bis 1 m/s Unterschied
  if AllowedSpeed > SpeedX + 1.0 then
    Result := 1.0
  else
und Fälschung
  //Gib Vollgas bis 10% vom maximal erlaubten m/s Unterschied
  if AllowedSpeed/SpeedX >1.10 then
    Result := 1.0
  else                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

//==========================================================================*
// Ansteuerung eines Zielpunktes
//--------------------------------------------------------------------------*
function TDriver.GetTargetPoint(LookAheadDistance: Tdble): TV2D;
var
  ...
  Plan: Tdble;
begin
  if oPit.InPit then
  begin
    ...
  end
  else
  begin
    ...
  end;

  Plan := oMyOffset;                         // Aktuelle Querabeichung merken
  Offset := PlanOffset;                      // Querabweichung planen
  if Abs(Offset) > 0.01  then                // Wenn Planung nicht 0 ist
    Plan := Offset;                          //   die verwenden
  if oPit.InPit then                         // Weg in Boxengasse nehmen?
    Offset := Sign(Plan) * Dist(S,P);        //   Querabweichung berechnen
  Result := Add(S,Mult(-Offset,N));          // Zielpunkt berechnen
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:

//==========================================================================*
// Aerodynamische Balance
//--------------------------------------------------------------------------*
procedure TFormMain.EditAngleChange(Sender: TObject);
var
  I: Integer;
  Hm: Double;            // ride height
  BodyLiftFront: Double; // Downforce at front
  BodyLiftRear: Double;  // Downforce at rear
  WingLiftFront: Double; // Downforce at front
  WingLiftRear: Double;  // Downforce at rear
  WingDragFront: Double; // Drag force at front
  WingDragRear: Double;  // Drag force at rear
  Ratio: Double;         // Ratio (Aerodynamische Balance)
  Line: string;
begin
  try
    MemoSpoiler.Lines.Clear;
    oCar.WingAngle[TEdit(Sender).Tag] := TEdit(Sender).Text;
    Hm := 0.0;
    // Mean weighted ride height at all wheels [m]
    for I := 0 to 3 do
      Hm := Hm + oCar.RideHeightVal[I];
    Hm := 1.5 * Hm;
    Hm := Hm * Hm;
    Hm := Hm * Hm;
    Hm := 2 * exp(-3.0 * Hm);

    BodyLiftFront := oCarType.Clift[FRONT] * HM;   // Down force at front
    BodyLiftRear := oCarType.Clift[REAR] * HM;     // Down force at rear

    WingLiftFront := 4.0 * 1.23                    // Down force at front
      * oCarType.WingArea[FRONT] * sin(oCar.WingAngleVal[FRONT]);
    WingLiftRear := 4.0 * 1.23                     // Down force at rear
      * oCarType.WingArea[REAR] * sin(oCar.WingAngleVal[REAR]);
    Ratio := (BodyLiftFront + WingLiftFront) /
      (BodyLiftFront + WingLiftFront + BodyLiftRear + WingLiftRear);

    Line := 'Resultierende aerodynamische Balance: ' + FloatToStr(Ratio);
      MemoSpoiler.Lines.Add(Line);

    WingDragFront := 1.23                          // Drag force at front
      * oCarType.WingArea[FRONT] * sin(oCar.WingAngleVal[FRONT]);
    WingDragRear := 1.23                           // Drag force at rear
      * oCarType.WingArea[REAR] * sin(oCar.WingAngleVal[REAR]);

    Line := 'Resultierender Luftwiderstandsbeiwert vorne: '
      + FloatToStr(WingDragFront);
    MemoSpoiler.Lines.Add(Line);
    Line := 'Resultierender Luftwiderstandsbeiwert hinten: '
      + FloatToStr(WingDragRear);
    MemoSpoiler.Lines.Add(Line);
  except
    Line := 'Ungültige Eingabe';
    MemoSpoiler.Lines.Add(Line);
  end;
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

    OldFactor := oCurrSec.SpeedSqrFactor;        // Aktueller Lernfaktor
    W := (Segment.Width * oWidthDiv - oBorder-CarWidth);
    Factor :=Abs(oActOffset)/W/oToleranz;
    {//Ausserhalb der Fahrbahn
    if Factor >EinEintel then
      begin
      Delta := (Factor-EinEintel)*oMMinus*OldFactor;
      N := 10;
      end
    else
    }
      begin
      if Factor < EinHalb then    // Je kleiner die Abweichung
        begin                     // umso größer die Erhöhung
        Delta := (Factor-EinHalb)*OldFactor *oMPlus;
        Writeln(oCurrSecID:5,'Schneller ',-delta:10:7,ABS(oActOffset):13:7,oActOffset:13:7,W:13:7);
        N := 6;
        end
      else //if oActOffset > oToleranz then          // bzw. die Erniedrigung
        begin                                        // Grenze ist 1,25 m
        Delta := (Factor-EinHalb)*OldFactor *oMminus;
        Writeln(oCurrSecID:5,'langsamer ',-delta:10:7,ABS(oActOffset):13:7,oActOffset:13:7,W:13:7);
        N := 12;
        end;
     end;
//...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

  // Quer-Abweichung vom geplanten Verlauf feststellen
  oActOffset := oCurrSec.GetOffset(Pos); // Aktueller Wert, nur in Kurven <> 0!!!
  if oActOffset = 0.0 then               // Wenn ich auf einer Geraden bin, 
  begin                                  //   Dann nehme ich den Wert der letzten
    oActOffset := oLastOffset;           //   Kurve und lasse den langsam ausklingen
    oLastOffset := oLastOffset * 0.98;   //   um zu wissen ob ich nach außen
  end                                    //   abweiche oder nach innen
  else                                   // ansonsten
  begin                                  //   merke ich mir den aktuellen Wert
    oLastOffset := oActOffset;           //   der Kurve für die folgende Gerade
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

  Factor :=2.0*Abs(oMyOffset)/(Segment.Width*oWidthDiv{0.0..1.0}-CarWidth-oBorder)/oToleranz;
 //Sind sehr nah an der Mitte dann rauf
  Delta :=0;
  if Factor < EinHalb then    // Je kleiner die Abweichung
    begin                                        // umso größer die Erhöhung
    Delta := (Factor-Einhalb)*oMPlus;
    N := 3;
    end
  else
     begin
     if Factor > 1 then
        Delta := 2.0*oMMinus
     else 
       if Factor > 0.7 then
         //Nur Kurvenaußenseite wird gedrosselt 
         IF oMyOffset*oCurrSec.Rad<0.0 then
              Delta := (Factor-Einhalb)*oMMinus;
          //Writeln(oCurrSecID,' ',Factor:4:2,' zu weit: ',Delta:10:7);
          N := 4;
          end;
  IF Delta <> 0.0 then
    begin
    Delta := OldFactor*Delta/LookAhead;// *1/N weggelassen
    for I := 0 to Round(N * LookAhead) do        // Lernfaktor auf den letzen
      begin                                      // X m anpassen
      Sec := oTrackDesc[oTrackDesc.Loop(oCurrSecID - I)]; 
      tm := (Sec.SpeedSqrFactor - Delta);
      if (tm < 0.3) then
        tm := 0.3
      else
        If (tm>3.0) then
          tm := 3.0;
      Sec.SpeedSqrFactor := tm;
      end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

  Fm  := mass*g;// Gewichtskraft

  for I := 0 to oCount - 1 do
  begin
    Sec := Section[I];
    Mu := Sec.oSeg.Surface.KFriction * TireMu * MuFactor;
    R := ABS(Sec.Rad);

    sinA :=sin(sec.okAlpha);
    cosA :=cos(sec.okAlpha);
    sinG :=sin(sec.okGamma);
    cosG :=cos(sec.okGamma);

    //Für kleine Winkel
    Fmq := -sinA*Fm; //Hangabtrieb quer
    Fml := sinG*Fm; //Hangabtrieb längs
    Fms := sqrt(sqr(Fm)-sqr(Fmq)-sqr(Fml)); //Der Rest senkrecht
    {
    Ff  := V*V*Abs(mass/R);   //Fliehkraft Krümmungskreis in Querrichtung
    Ffs := sinA*Ff;      //senkrecht zur Fahrbahn
    Ffq := cosA*Ff;      //quer zur Fahrbahn die eigentliche Wirkrichtung
    Ffl := 0.0;          //in Längsrichtung

    Fas := CA*V*V;         //Aerodynamische Anpressung genau senkrecht zur Fahrbahn

    Fs := Fms+Ffs+Fas;
    Fq := Fmq+FFq;
    //Fq==mue*Fs-> Grenzbedinung fürs Rutschen
    //mu*Fms-Fmq=Ffq-mu*Ffs
    //mu*...=V2*Abs(mass/R)*(cos(Sec.okAlpha)-mu*sin(Sec.okAlpha))
    //V2=oSSq=
    }
     
    IF R > 2000 then    //Sehr grosser Radius hat keinen Einfluß
      Sec.oSSq := MAX_SSq
    else
      begin
      //Neigung Strasse passend zur Kurve
      If Sec.Rad<=0.0 then
        V0 :=(cosA/mu+sinA)*mass/R-CA
      else
        V0 :=(cosA/mu-sinA)*mass/R-CA;

      IF V0 < 0 then //In überhöhten Kurven kann das passieren
        Sec.oSSQ := MAX_SSq
      else
        Sec.oSSq:= Fs/V0;
      end;
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:

program OptBremsWeg;
uses
  debug;
type
  Tdble = extended;
const
  g : tDble = 9.81;
  s_max = 10000.0;
var
  A,
  mue,
  alpha,
  sinA,
  cosA,
  gamma,
  sinG,
  cosG,
  yR,
  zR,

  mass,

  mueFahrbahn,
  mueRoll,
  mueSumm ,
  Luftdichte,
  Cw,
  ca,
  V0,
  V,
  V2,
  Ve,
  Vw,
  E,
  dE,


  F,
  Fl,
  Fq,
  Fs,
  Fb,
  Fmax,
  Flges,

  Ff,
  Ffq,
  Ffl,
  Ffs,

  Fm,
  Fmq,
  Fml,
  Fms,

  Fa,
  Faq,
  Fal,
  Fas,

  Fk,
  Fkq,
  Fkl,
  Fks,

  h,
  s,ds :Tdble;

function DeltaE(V2,ds:Tdble):Tdble;
begin
  //sekrechte Kräfte auf die geneigte Fläche umrechnen
  sinA := sin(Alpha);
  cosA := cos(Alpha);
  sinG := sin(Gamma);
  cosG := cos(Gamma);

  Fm  := mass*g;
  Fmq := cosA*sinG*Fm; //Hangabtrieb quer
  Fml := sinA*cosG*Fm; //Hangabtrieb längs
  Fms := sqrt(sqr(Fm)-sqr(Fmq)-sqr(Fml)); //Der Rest senkrecht

  Ff  := mass*V2/yR;   //Fliehkraft Krümmungskreis in Querrichtung
  Ffs := sinA*Ff;      //senkrecht zur Fahrbahn
  Ffq := cosA*Ff;      //quer zur Fahrbahn die eigentliche Wirkrichtung
  Ffl := 0.0;          //in Längsrichtung

  Fk  := mass*V2/zR;   //Kuppen und Täler,Krümmumgkreis in Längsrichtung

  Fks := cosG*Fk;      //senkrecht zur Fahrbahn die eigentliche Wirkrichtung
  Fkq := sinG*Fk;      //quer zur Fahrbahn
  Fkl := 0.0;          //in Längsrichtung

  Fas := ca*V2; //Aerodynamisches anpressen;// Wirkt genau senkrecht auf die Fahrbahn
  //Faq         //Aerodynamische Querkraft Seitenwind
  Fal := cw*V2; //Aerodynamisches Bremsen Luftwiderstand

  Fs := Ffs+Fms+Fks+Fas;  //Kraft senkrecht auf Fahrbahn
  Fq := Ffq+Fmq+Fkq;      //Kraft quer zur Fahrbahn
  Fl := Ffl+Fml+    Fal;  //Kraft in Fahrrichtung

  //Auf Fahrbahn durch die Reifen übertragbare Gesamtkraft
  IF Fs< 0.0 then
    Begin
    writeln(S,' Wir heben ab ',V);
    halt(-1);
    end;

  Fb := mueSumm*Fs;
  //Bremskraft des Wagens in Wagenrichtung ,Die Querkraft muss auch durch
  //die Reifen übertragen werden.
  Fmax := sqr(Fb)-sqr(Fq);
  //Rutschen wir schon, dann war es das
  IF Fmax > 0 then
    Fmax := sqrt(Fmax)
  else
    Begin
    Fmax := 0.0;
    writeln(S,' Wir rutschen ',V);//Aber Längskräfte bremsen oder beschleunigen noch
    halt(-1);
    end;

  Flges  := Fmax+Fl;
  {
  writeln('rel Beschleunigung : ',Flges/(mass*g));
  Writeln('Fg      : ',Fm);
  Writeln('Fflieh  : ',Ff);
  Writeln('FLoop   : ',Fk);
  Writeln('FAeroCa : ',Fas);
  Writeln('FAeroCw : ',Fal);
  }
  DeltaE := -Flges*ds;
end;

function Heun(V,h,ds:tdble):tdble;
//ausreichend genau, wenn sich nicht sich zu viele Parameter gleichzeitig
//während eines Schrittes aendern
var
  E0,dE1,dE2,
  h1,V2: tDble;
Begin
  V2 := sqr(v);
  E0 := (g*h +0.5*sqr(V))*mass;
  h := h+ds*sinA;//neue geodätische Höhe man kann auch Startziel als 0 nehmen
  dE1 := DeltaE(V2,ds);
  V2 := ((E0+dE1)/mass-g*h)*2.0;
  dE2 := DeltaE(V2,ds);
  V2 := ((E0+0.5*(dE1+dE2))/mass-g*h)*2.0;
  If V2 > 0 then
    V := sqrt(V2)
  else
    V:= 0;//Rollt eigentlich rückwärts, kann auch ein überschiessen sein
//  Writeln(s:8:4,E0:15:6,dE1:15:6,dE2:15:6,V:15:6);
  Heun := V;
end;

begin
  V0 := 30;
  A := 2.0;
  alpha :=-10.0*pi/180;   //Längsneigung
  gamma := 0*pi/180;   //Querneigung
  sinA := sin(Alpha);
  cosA := cos(Alpha);
  sinG := sin(Gamma);
  cosG := cos(Gamma);
  yR := 100;//Enge Kurve
  zR:= 1e38; //+Innenlooping(bergab->bergauf),bergauf -> bergab
  mueFahrbahn := 1.0;
  mueRoll:= 0.00;
  Luftdichte := 1.2;
  Cw := 0.5*Luftdichte*0.41*A;
  ca := 0.5*Luftdichte*2.3*A;
  mass := 1050.0;

  mueSumm := mueFahrbahn+mueRoll;


  ds := 8.0;
repeat;
  s := 0.0;
  h := 1000;
  V := V0;
  v2:=sqr(v);
  E := (0.5*V2+g*h)*mass;
  repeat
    h := h+ds*sinA;
    E := E+DeltaE(V2,ds);
    V2 := (E/mass-g*h)*2.0;
    If V2 < 0 then
      break;
    V := sqrt(V2);
    s := s+ds;
    If Abs(s-48) < ds then
      writeln(s:6:3,V:10:6,ds:10:6);
  until s>s_max;//Notbremse
  ds := ds*0.5;
until ds <1/8;
  writeln;


  ds := 8.0;
repeat
  s := 0.0;
  h := 1000;
  V := V0;
  E := (0.5*sqr(V)+g*h)*mass;

  repeat
    V:=Heun(V,h,ds);
    s := s+ ds;
    If Abs(s-48) < ds then
      writeln(s:6:3,V:10:6,ds:10:6);
  until (V <= 0.0) or (s>s_max);
  writeln(s:10:6,v:15:6,Heun(V,h,ds):15:6);
  ds := ds*0.5;
until ds <1/8;

end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

(Euler-Cauchy)
S      V          ds
48.000 22.980188  8.000000
48.000 22.610156  4.000000
48.000 22.416512  2.000000
48.000 22.317575  1.000000
48.000 22.267585  0.500000
48.000 22.242462  0.250000
48.000 22.229868  0.125000

(Heun)
48.000 22.273808  8.000000
48.000 22.232475  4.000000
48.000 22.221205  2.000000
48.000 22.218260  1.000000
48.000 22.217507  0.500000
48.000 22.217316  0.250000
48.000 22.217269  0.125000                    

1:
2:
3:
4:
5:

  if oPit.InPit then                             // In der Boxengasse den
    Offset := Mult(oCurrSec.Tor2D,Sub(S,P))      // Offset aus Rennstrecke
  else                                           // statt Fahrzeug ermitteln
    Offset := PlanOffset;                        // ansonsten je nach
  Result := Add(S,Mult(-Offset,N));              // Situation steuern                    

1:

  if Distance > 0.9 * Driver.Opponents[I].Distance then                    

1:
2:
3:
4:

<attnum name="max pressure" unit="kPa" min="100" max="150000" val="43000"/>
..
<attnum name="shift" unit="1" min="0" max="1.0" val="0.91"/>
<attnum name="shiftmargin" unit="1" min="0" max="10" val="4.0"/>                    

1:
2:
3:
4:

<attnum name="max pressure" unit="kPa" min="100" max="150000" val="100"/>
..
<attnum name="shift" unit="1" min="0" max="1.0" val="0.2"/>
<attnum name="shiftmargin" unit="1" min="0" max="10" val="10.0"/>                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

//==========================================================================*
// Bremsweg schätzen
//--------------------------------------------------------------------------*
function TDriver.BrakeDist(TargetSpeedSqr, Mu: Tdble): Tdble;
var
  C, D: Tdble;
begin
  C := Mu * G;
  D := (Ca * Mu + Cw) / Mass;
  Result := -ln((C + TargetSpeedSqr*D) / (C + CurrSpeedSqr*D)) / (2.0 * D);
end;
//==========================================================================*

//==========================================================================*
// Bremsweg schätzen
//--------------------------------------------------------------------------*
function TDriver.BrakeDist(ActSpeedSqr,TargetSpeedSqr, Mu: Tdble): Tdble;
var
  C, D: Tdble;
begin
  C := Mu * G;
  D := (Ca * Mu + Cw) / Mass;
  Result := -ln((C + TargetSpeedSqr*D) / (C + ActSpeedSqr*D)) / (2.0 * D);
end;
//==========================================================================*

//==========================================================================*
// Bremsweg schätzen
//--------------------------------------------------------------------------*
class function TDriver.BrakeDist(ActSpeedSqr,TargetSpeedSqr
  ,Mu,Ca,Cw,Mass: Tdble): Tdble;
var
  C, D: Tdble;
begin
  C := Mu * G;
  D := (Ca * Mu + Cw) / Mass;
  Result := -ln((C + TargetSpeedSqr*D) / (C + ActSpeedSqr*D)) / (2.0 * D);
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:

//==========================================================================*
// Geschwindigkeitsregelung zur Einhaltung des Tempolimits in der Boxengasse
//--------------------------------------------------------------------------*
function TFilterBrakePit.Filter(Signal: Tdble):Tdble;
const
  PIT_BRAKE_AHEAD = 200.0; // [m] Workaround for "broken" pitentries
var
  DL, Dw: Tdble;
  S: Tdble;
  Dist: Tdble;
begin
  Result := Signal;

  if oDriver.Pit.PitStop                         // Anfahrt zum Eingang
    and (not oDriver.Pit.InPit) then             // der Boxengasse?
  begin                                          // Falls Einfahrt zur Box
    RtDistToPit                                  // sehr kurz ist, Abstand
      (oDriver.Car^,oDriver.Track^,DL,Dw);       // Box bestimmen
    if DL < PIT_BRAKE_AHEAD then                 // und Bremspunkt
    begin                                        // überwachen, ggf.
      if Driver.BrakeDist(0.0,oDriver.PitMu) > DL then
      begin                                      //   Sofort
        Result := 1.0;                           //   eine Vollbremsung
        Exit;                                    //   hinlegen
      end;
    end;
  end;

  if oDriver.Pit.InPit then                      // Sind wir in Boxengasse?
  begin                                          // Wenn ja
    S := oDriver.Pit.Station(oDriver.DistFromStartLine);
    if oDriver.Pit.PitStop then                  //   noch auf der Anfahrt?
    begin
      Dist := oDriver.Pit.NPitStart - S;         // Abstand vom Beginn Temol.
                                                 // Bremspunkt bezogen auf
                                                 // Beginn des Tempolimits
      if ((S < oDriver.Pit.NPitStart)            // oder Tempolimit selbst
        and (oDriver.BrakeDist(oDriver.Pit.SpeedLimit,Driver.PitMu) > Dist))
        or ((S > oDriver.Pit.NPitStart)
        and (oDriver.CurrSpeedSqr > oDriver.Pit.SpeedLimitSqr)) then
        Result := oDriver.Pit.GetPitSpeedLimitBrake(Driver.CurrSpeedSqr);

      Dist := oDriver.Pit.NPitLoc - S;           // Abstand von der Box
      if oDriver.Pit.IsTimeout(Dist) then        // Abbruch wenn kein Service
      begin
        oDriver.Pit.PitStop := False;
        Result := 0.0;
      end
      else // Zusätzlich überwachen: Bremspunkt für Stillstand in Box
      begin
        if (S <= oDriver.Pit.NPitLoc)            // Wir sind noch vor der Box
          and (oDriver.BrakeDistPit > Dist) then // haben aber Bremspunkt für
          Result := 1.0                          //   Box schon erreicht
        else if S > oDriver.Pit.NPitLoc then     // Wir sind angekommen
        begin                                    // Beim Stehen in der Box
          oDriver.GearCmd := 0;                  //   Gang raus
          oDriver.AccelCmd := 0.0;               //   Gas weg
          oDriver.Standing := True;              //   Flag für Unstuck-Pause
          oDriver.ClutchCmd := 1.0;              //   Kupplung treten
          Result := 1.0;                         //   Bremsen
        end;
      end;
    end
    else // Wir sind schon auf der Ausfahrt
    begin
      if S < oDriver.Pit.NPitEnd then
      begin // Noch gilt Tempolimit
        if oDriver.CurrSpeedSqr > oDriver.Pit.SpeedLimitSqr then
          Result := oDriver.Pit.GetPitSpeedLimitBrake(Driver.CurrSpeedSqr);
      end;
    end;
  end;
end;
//==========================================================================*

//==========================================================================*
// Abbremsen wegen eines Rivalen oder eines Teammitgliedes
//--------------------------------------------------------------------------*
function TFilterBrakeColl.Filter(Signal: Tdble): Tdble;
var
  I: Int;
  Mu: Tdble;
  Distance: Tdble;
begin
  Result := Signal;

  Mu := Driver.Mu;
  for I := 0 to Driver.Opponents.Count - 1 do
  begin
    if (Driver.Opponents[I].State and OPP_TEAMBRAKE) <> 0 then
      Result := Max(0.5,Result);

    if (Driver.Opponents[I].State and OPP_COLL) <> 0 then
    begin
      Distance := FRONTCOLL_MARGIN + Driver.BrakeDist    // Hier wird er gebraucht
        (Driver.SpeedX,Driver.Opponents[I].Speed,Mu);
      if Distance > 0.9 * Driver.Opponents[I].Distance then
      begin
        Result := 1.0;
        Exit;
      end;
    end;
  end;
end;
//==========================================================================*                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

const
BOTNAME_ATT_WIDTHDIV = 'useable road width';   // Anteil Fahrbahn
dann:
TDriver = class(TDriverBaseClass)
  private
    oActOffset: Tdble;                           // Kursabweichung
    oAeroMagic: Tdble;                           // Ca-Tuningfaktor
    oAlone: Integer;                             // Indikator für Umfeld
    oBorder: Tdble;                              // Randabstand
    oBrakeDistPit: Tdble;                        // Bremsabstand für Box

    oWidthDiv : tDble;                           // Nutzbare Strassenbreite
.....
  property WidthDiv : tDble
      read oWidthDiv;
  
//==========================================================================*
// Experte für die Einstellung des Rennwagens
//--------------------------------------------------------------------------*
procedure TDriver.GetParamExpert(var CarSettings: PCarSettings);
var
  Fuel: Tdble;
begin
....
 oWidthDiv := GfParmGetNum(CarSettings
    , BOTNAME_PRIV, BOTNAME_ATT_WIDTHDIV
    ,nil,3.0);
  WriteLn(Format('WidthDiv: %0.2f',[oWidthDiv]));
....                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

    begin
      Tm := Abs(Driver.ToMiddle);
      W := Seg.Width / Driver.WidthDiv;
      if Tm > W then
        Result := 0;
    end;
  end;
end;
//==========================================================================*
end.
//--------------------------------------------------------------------------*
// end of file UnitFilter.pas
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*                    

1:

    <attnum name="useable road width" unit="1" min="2" max="100" val="2"/>                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

Driver         R   P    R   TS    Best Lap Laps Pit    D     Time     R   Best Lap 
Mouse 2006 1    1  20   1  290.6  1:15.104  105  2   813  2:19:06.10   1  1:15.364  
Mouse 2006 2    2  18   2  289.7  1:15.102  105  2  1021  2:19:54.89   2  1:15.364  
dummy_2006 1    3  16   4  287.3  1:16.896   99  2  2900  2:19:44.78   5  1:16.026  
Lobo Malo       4  15   5  291.1  1:19.440   98  3  1288  2:21:01.26   6  1:17.606  
Lupo Bianco     4  15   5  293.0  1:19.454   97  3  2780  2:20:49.09   5  1:17.606  
R Daneel        6  14   6  287.0  1:18.532   97  3  4061  2:20:49.87   7  1:18.078  
stanley_2007 2  7  13   7  283.0  1:26.566   93  3   476  2:20:59.79  12  1:27.390  
berniw 2004 1   8  11   9  280.0  1:24.996   93  2   910  2:20:22.51   9  1:21.822  
dummy_2006 2    8  11   9  288.6  1:16.886   93  2  3485  2:19:44.68   6  1:19.368  
stanley_2007 1  8  11   9  282.7  1:25.700   93  3  5919  2:20:27.45  11  1:26.666  
tp 1_2006      11  10  10  279.3  1:27.334   92  2  1282  2:20:41.74  13  1:31.502  
berniw 2004 2  12   9  11  278.7  1:24.614   87  2  2498  2:19:45.32  10  1:21.822  
tp 2_2006      12   9  11  278.5  1:28.740   89  2   975  2:21:02.84  14  1:32.244  
polimi_2007 1  14   7  13  278.3  1:30.838   84  2  1861  2:20:22.56  16  1:35.620  
polimi_2007 2  14   7  13  278.1  1:31.910   83  2  2362  2:20:29.04  15  1:35.202  
R Giskard      14   7  13  287.3  1:18.810   85  1  6229  2:19:39.04   5  1:17.402                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

Team                Rang  Punkte   
The Rat Race          1    40     
wdbee                 2    32     
dummy drivers         3    29     
Stanley               4    26     
USR                   5    23     
Berniw Racing         6    22     
TORCSPlayer Racing    7    19     
PoliMi Racing Team    8    16                    

1:

   Translation (parts of the Delphin-Robot, from Delphi to c++) to be able to sign in to the championship 2007