function TSTW_Pathfinder.CheckConnection(P0: TVector2f; P1: TVector2f): Boolean;
var
  dX, dY, Slope, Error: Single;
  StepX, StepY, Max:    Integer;
  TruncX0, TruncY0:     Integer;
  Count, Calc:          ^Integer;
begin
// Schrittvariablen initialisieren
StepX   := 0;
StepY   := 0;

// Differenzen aus den Koordinaten errechnen, und daraus die Steigung
// (ohne Vorzeichen)
dX      := P1.X - P0.X;
dY      := P1.Y - P0.Y;
Slope   := Abs(dY / dX);

// Feststellen, in welchem Feld der Karte der Startpunkt liegt (entspricht dem
// ganzzahligen Anteil der Koordinaten
TruncX0 := Trunc(P0.X);
TruncY0 := Trunc(P0.Y);


if Slope < 1 then
  begin
// Wenn die Steigung kleiner ist als eins...
//    ...Fehlervariable als Schnittpunkt der Geraden zwischen den beiden Punkten
//    mit dem linken "Rand" des Startfeldes initialiseren. -1 wäre die linke untere Ecke,
//    0 ist die Ecke links oben. (Um leichter darauf testen zu können, ob ich nah an der
//    oberen Ecke bin diese seltsame Konvention - bei Fließkommazahlen ist ein Test x = -1?
//    ja immer ungenau.
  Error   := Frac(P0.Y) - Slope * Frac(P0.X) - 1;
  Count   := @StepX;  // Pointerzuweisungen, sorgen dafür das später
  Calc    := @StepY;  // der x-Wert als Schleifenvariable dient und der y-Wert berechnet wird
  Max     := Abs(Trunc(P1.X) - TruncX0);  // Maximalwert für die Zählvariable in der Schleife
  end
  else
  begin
//  Wenn nicht - machen wir das gleiche, vertauschen aber x- und y-Koordinaten,
//  um den selben Algorithmus benutzen zu können
  Slope   := 1 / Slope;
  Error   := Frac(P0.X) - Slope * Frac(P0.Y) - 1;
  Count   := @StepX;
  Calc    := @StepY;
  Max     := Abs(Trunc(P1.Y) - TruncY0);
  end;

while Count^ < Max do // Schleife über die Zählvariable
  begin
  // Der eigentliche Feldtest: da wo FPathmax[x, y] = false ist, ist der Weg frei.
  Result := not FPathmap[TruncX0 + Sign(dX) * StepX, TruncY0 + Sign(dY) * StepY];
  if not Result then
    Exit;

  // Wenn ein Feld getestet ist, addieren wir die Steigung zur Fehlervariablen -
  // so bekomm ich dann den Schnittpunkt mit der nächsten "Feldkante".
  Error := Error + Slope;
  if Abs(Error) <= 0.05 then
    // Ist die Fehlervariable nah an 0, geht die gerade quasi genau durch den Punkt,
    // an dem sich 4 Felder treffen - zusätzlich zu dem Feld, das im nächsten Durchlauf
    // eh getestet wird muss ich mich also auch um das darunter und das links daneben kümmern.
    begin
    Result := not FPathmap[TruncX0 + Sign(dX) * StepX,
                  TruncY0 + Sign(dY) * (StepY + 1)];
    Result := Result and not FPathmap[TruncX0 + Sign(dX) * (StepX + 1),
                                      TruncY0 + Sign(dY) * StepY];
    if not Result then
      Exit;

    if Error > 0 then
      // Wenn die Fehlervariable größer ist als null wandere ich ein Feld höher
      // und betrachte den Schnittpunkt mit der Kante des Feldes darüber ->
      // Die Fehlervariable wird wieder um eins gesenkt
      Error := Error - 1;

    // Bin ich nah an null lande ich auf jeden Fall auch auf der y-Achse eine Einheit
    // weiter "oben" - außer dX wäre sehr groß und dY sehr, sehr klein - das sollte aber nicht passieren.
    Calc^ := Calc^ + 1;
    end
    else
    if Error > 0 then
      // Wenn wir nicht nah an null sind, aber größer als null, interessiert mich nur das Feld
      // über dem gerade getesteten - Error um eins senken, die berechnete Variable um eins erhöhen,
      // testen, fertig.
      begin
      Calc^ := Calc^ + 1;
      Error := Error - 1;
      Result := not FPathmap[TruncX0 + Sign(dX) * StepX,
                             TruncY0 + Sign(dY) * StepY];
      if not Result then Exit;
      end;

  // Zählvariable um eins erhöhen, rinse, repeat.
  Count^ := Count^ + 1;
  end;
end;