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:

unit umehrkoerper;

interface
uses SysUtils, math, Uplanet, UVektor;

type Tmehrkoerper=class(TPlanet)
  protected
  Planet: array of TPlanet;
  maxV, minV, maxOrt, minOrt:TVektor;
  anzahl:longint;
  G:extended;
  zeitschritt,zeit:extended;
  public
[...]
    procedure berechnen;

end;
implementation

[...]

procedure tmehrkoerper.berechnen;
var i,j:integer; betrag,ax,ay,vxneu,vyneu,xneu,yneu:extended; abstand:TVektor;
begin
  for i:=0 to high(planet) do
    for j:=0 to high(planet) do
      if i<>j then begin
        abstand:=planet[i].ortalt.vektordifferenz(planet[j].Ortalt);
        betrag:=power(abstand.Betrag,3);
        ax:=(g*planet[j].getmasse*abstand.getx) / betrag;
        ay:=(g*planet[j].getmasse*abstand.gety) / betrag;
        vxneu:=planet[i].valt.getx + (ax*zeitschritt);
        vyneu:=planet[i].valt.gety + (ay*zeitschritt);
        xneu:=planet[i].ortalt.getx + (vxneu*zeitschritt);
        yneu:=planet[i].ortalt.gety + (vyneu*zeitschritt);
        planet[i].neuevektoren(vxneu,vyneu,xneu,yneu); {hier ist die anweisung, nach der es abstürzt}
      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:

unit UPlanet;

interface
uses SysUtils, math, UVektor;

type TPlanet=class(TVektor)
  protected
     Vstart:TVektor;
     Ortstart:TVektor;
     Masse:extended;
  public
     Ortalt,ortneu:TVektor;
     Valt,vneu:TVektor;
[...]
     procedure neuevektoren(vx,vy,x,y:extended);

     
end;

implementation

[...]
procedure TPlanet.neuevektoren(vx,vy,x,y:extended);
  begin
    self.Valt:=vstart.kopierevektor;
    self.Ortalt:=ortstart.kopierevektor;
    self.vneu.setzex(vx); {die nächste Anweisung}
    self.vneu.setzey(vy);
    self.ortneu.setzex(x);
    self.ortneu.setzey(y);
  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:

unit UVektor;

interface
uses SysUtils, math;

type TVektor=class
  protected
    x,y:extended;

  public
[...]
    procedure setzex(x:extended);
    procedure setzey(y:extended);
[...]

end;

implementation
[...]
procedure TVektor.setzex(x:extended);
begin
  self.x:=x;
end;
[...]					

1:

vneu:= TVector.Create;					

1:

self.x:=vektor.x;					

1:

self.x:=x;					

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

constructor TPlanet.create(Vstart,Ortstart:TVektor;masse:extended);
  begin
     self.vstart:=TVektor.create(Vstart);
     self.Ortstart:=TVektor.create(Ortstart);
     self.vneu:=TVektor.create(0,0);
     self.ortneu:=TVektor.create(0,0);
     self.valt:=TVektor.create(vstart);
     self.ortalt:=TVektor.create(ortstart);
     self.masse:=masse;
  end;					

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

constructor TPlanet.create(Vstart,Ortstart:TVektor;masse:extended);
  begin
     self.vstart:=TVektor.create(Vstart);
     self.Ortstart:=TVektor.create(Ortstart);
     self.vneu:=TVektor.create(0,0);
     self.ortneu:=TVektor.create(0,0);
     self.valt:=TVektor.create(vstart);
     self.ortalt:=TVektor.create(ortstart);
     self.masse:=masse;

     inherited Create;
  end;					

1:
2:
3:
4:
5:

[...]
  abstand:=planet[i].ortalt.vektordifferenz(planet[j].Ortalt);      // abstand = (0,0)
  betrag:=power(abstand.Betrag,3);            // betrag = 0
  ax:=(g*planet[j].getmasse*abstand.getx) / betrag;             // bumm 
[...]					

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

procedure tmehrkoerper.berechnen2(planetenfeld:Planet);
var i,j:integer; betrag,ax,ay,vxneu,vyneu,xneu,yneu:extended; abstand:TVektor;
begin
  for i:=0 to high(planetenfeld) do
    for j:=0 to high(planetenfeld) do
      if planetenfeld[i]<>planetenfeld[j] then begin
        abstand:=planetenfeld[i].ortalt.vektordifferenz(planetenfeld[j].Ortalt);
        betrag:=power((sqr(abstand.Betrag)+sqr(e)),1.5);
        ax:=(g*planetenfeld[j].getmasse*abstand.getx) / betrag;
        ay:=(g*planetenfeld[j].getmasse*abstand.gety) / betrag;
        vxneu:=planetenfeld[i].valt.getx + (ax*zeitschritt);
        vyneu:=planetenfeld[i].valt.gety + (ay*zeitschritt);
        xneu:=planetenfeld[i].ortalt.getx + (vxneu*zeitschritt);
        yneu:=planetenfeld[i].ortalt.gety + (vyneu*zeitschritt);
        planetenfeld[i].neuevektoren(vxneu,vyneu,xneu,yneu);
        abstand.Destroy;
      end;
end;