Autor Beitrag
F34r0fTh3D4rk
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 5285
Erhaltene Danke: 29

Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
BeitragVerfasst: Sa 18.06.05 13:48 
Hallo, ich habe meine kleine Klasse TBall und möchte jetzt eine Kollisionsabfrage einbauen, das Problem ist, wie prüfe ich das am besten ? jeden mit jedem zu überprüfen macht nicht viel sinn, weil dann viele doppelt getestet werden, was ja nicht sein muss. [math]und wie bekomme ich ein realistisches abprallen, wenn die bälle zb nicht direkt aufeinander treffen (also kein energietausch)?[/math], hier mein code:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
procedure c_balls;
var
  i, j: integer;
  a, b, c: integer;
  nrg_buf_x, nrg_buf_y: integer;
begin
  for i := low(Balls) to high(Balls) do
    for j := low(Balls) to high(Balls) do
      begin
        a := Balls[j].x - Balls[i].x;
        b := Balls[j].y - Balls[i].y;
        c := round(sqrt(sqr(a) + sqr(b)));
        if c <= Balls[j].radius + Balls[i].radius then
          begin
            nrg_buf_x := Balls[j].xspeed;
            nrg_buf_y := Balls[j].yspeed;
            Balls[j].xspeed := Balls[i].xspeed;
            Balls[j].yspeed := Balls[i].yspeed;
            Balls[i].xspeed := nrg_buf_x;
            Balls[i].yspeed := nrg_buf_y;
          end;
      end;
end;


EDIT: den mathekram hab ich gefunden: freespace.virgin.net...s/models/m_snokr.htm
Check ich aber net richtig :lol:

Nur wie Frage ich am geschicktesten nur alle Kugeln einmal ab, weil eine abfrage = 2 kugeln :idea:

Beim jetzigen Code werden nur die Energien getauscht, aber die Kollision findet fast nie statt, also werden wohl nicht alle kugeln abgefragt !?

Vielen dank schonal :D
patrick
ontopic starontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic star
Beiträge: 1481

WIN2k, WIN XP
D6 Personal, D2005 PE
BeitragVerfasst: Sa 18.06.05 21:29 
ich geb dir mal etwas denkunterstützung:
sobald du einen ball anstößt, bewegt sich dieser mit der zugewendeten kraft in eine bestimmte richtung (TBewegender_Ball -kannst du von TBall ableiten), jetzt must du überprüfen, ob auf dieser strecke ein weiterer TBall ist, welcher mit dem TBewegender_Ball kollidiert.
jetzt greift diese erklärung, die du von der homepage gefunden hast.
nach dem aufprall hast du dann eine weitere instanz von TBewegender_Ball

eine sinnvolle klassenaufteilung würde z.B. so aussehen:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
  type TBall = class(TObject)
    x,
      y,
      Durchmesser:integer;
  end;

  type TBewegenderBall = class(TBall)
    Richtung,
      Energie:integer;
  end;

  type TSpielFeld = class(TObject)
    Hoehe,
      Breite,
      Taschendurchmesser,
      Reibungsfaktor,
      Abprallfaktor:integer;
  end;

_________________
Patrick
im zweifelsfall immer das richtige tun!!!
F34r0fTh3D4rk Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 5285
Erhaltene Danke: 29

Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
BeitragVerfasst: So 19.06.05 12:29 
aber was ist mit dem alten TBall ? reicht es nicht, ich finde die eigentschaften xspeed und yspeed sollten doch ausreichen, nur verstehe ich die formel net, und meine abfrage ist auch "müll" :D
delfiphan
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: So 19.06.05 12:52 
Kollisionserkennung: Wieviele Kugeln hast du denn. Falls es weniger als 50 sind kannst du ruhig alle mit allen. Um nicht alle doppelt zu zählen machst du einen geordneten Schleifendurchlauf. Du machst also eine Doppelsumme über i und j, gibst aber vor, dass i grösser als j sein muss.
Dann kommt z.B. Ball 1 <-> Ball 3 vor, jedoch nicht Ball 3 <-> Ball 1.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
const
 N = 4;
var
 i, j: Integer;
begin
  // Entweder
  for i := 1 to N do
   for j := 1 to N do
    if i > j then
    begin
     Memo1.lines.add(format('%d %d',[i,j]));
    end;

  // Oder optimiert:
  for i := 1 to N do
   for j := 1 to i-1 do
   begin
     Memo1.lines.add(format('%d %d',[i,j]));
   end;


Falls es sehr viele Kugeln sind, kannst du eine Art Bucket Sort in 3D machen. Das geht dann in linearer Zeit. Was die Physik angeht: Wenn die Kugeln alle gleich schwer sind kannst du (ausm Bauch raus) einfach die Normalkomponenten der Geschwindigkeiten vertauschen. Oder wenn's du allgemein willst nimmst du einfach die Formeln ;)


Zuletzt bearbeitet von delfiphan am So 19.06.05 13:07, insgesamt 1-mal bearbeitet
F34r0fTh3D4rk Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 5285
Erhaltene Danke: 29

Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
BeitragVerfasst: So 19.06.05 13:06 
ja danke, so funktioniert schonmal die abfrage, aber die reaktion ist noch physikalisch inkorrekt (reibung muss auch noch rein ^^)
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
procedure c_balls;
var
  i, j: integer;
  a, b, c: integer;
  nrg_buf_x, nrg_buf_y: integer;
begin
  for i := low(Balls) to high(Balls) do
   for j := low(Balls) to i - 1 do
      begin
        a := Balls[j].x - Balls[i].x;
        b := Balls[j].y - Balls[i].y;
        c := round(sqrt(sqr(a) + sqr(b)));
        if c <= Balls[j].radius + Balls[i].radius then
          begin
            nrg_buf_x := Balls[j].xspeed;
            nrg_buf_y := Balls[j].yspeed;
            Balls[j].xspeed := Balls[i].xspeed;
            Balls[j].yspeed := Balls[i].yspeed;
            Balls[i].xspeed := nrg_buf_x;
            Balls[i].yspeed := nrg_buf_y;
          end;
      end;
end;
delfiphan
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: So 19.06.05 13:10 
Du hast ja oben einen Link gepostet wo es erklärt wird ;)
Ansonsten such nach: Impulserhaltung, inelastischer Stoss, elastischer Stoss
F34r0fTh3D4rk Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 5285
Erhaltene Danke: 29

Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
BeitragVerfasst: So 19.06.05 13:18 
gut werde ich, ich brauche außerdem die dichte des materials aus dem eine billardkugel besteht, ich guck mal bei wiki woraus die bestehen, dann kann ich aus dichte und radius die masse berechnen, die ich dafür bestimmt brauchen werde, danke :wink:

ok hab alle normen zu tischen kugeln und dergleichen gefunden *freu*

www.poolbillard-sach...erialnormen_Pool.pdf


kann ich die kollisionsabfrage irgendwie noch optimieren, weil es passieren kann, dass eine kugel zu weit geht und hängen bleibt, dieses zuweit gehen wirkt sich auch negativ auf die berechnungen aus, ok ich könnte ein niedrigeres timer-interval nehmen, was aber auch net alzu klug gelöst wäre, wie ist das zb bei icq pool, das scheitn recht gut zu funzen :?

aber damit kann ich nichts anfangen: de.wikipedia.org/wiki/Impulserhaltung

die berechnungen werden eh nicht alzu einfach wegen xspeed und yspeed, sollte man aber mit x und y umrechnen können, zu nem winkel oder was gerade gebraucht wird, aber ich versteh den kram nunmal leider net ^^ gibts irgendwo n tutorial, opensource bespiel, irgendwas ähnliches ?
F34r0fTh3D4rk Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 5285
Erhaltene Danke: 29

Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
BeitragVerfasst: So 19.06.05 13:52 
schon etwas besser, die wandkollisionen sind jetzt schonmal fehlerfrei, die ball kollisionen sind eh noch net fertig, bissl reibung ist auch drin, aber wie ich das realistisch einbaue weiß ich auch net :bawling:
ausblenden volle Höhe Delphi-Quelltext
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:
unit UMain;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls;

type
  TForm1 = class(TForm)
    Image1: TImage;
    Button2: TButton;
    Timer1: TTimer;
    Label1: TLabel;
    Edit1: TEdit;
    Edit2: TEdit;
    Label2: TLabel;
    Label3: TLabel;
    Edit3: TEdit;
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private

  public

  end;

type
  TBall = class
    x, y, radius: integer;
    xspeed, yspeed: double;
    color: TColor;
    Mass: integer;
    procedure Draw(Canvas: TCanvas);
  end;

var
  Form1: TForm1;
  Balls: array of TBall;

implementation

{$R *.DFM}

procedure TBall.Draw(Canvas: TCanvas);
begin
  with canvas do
    begin
      brush.color := color;
      ellipse(x - radius, y - radius, x + radius, y + radius);
    end;
end;

procedure c_walls(Ball: TBall);
begin
  if (ball.x - ball.radius) <= 0 then
    if ball.xspeed < 0 then
      ball.xspeed := - ball.xspeed;
  if (ball.x + ball.radius) >= Form1.image1.width then
    if ball.xspeed > 0 then
      ball.xspeed := - ball.xspeed;
  if (ball.y - ball.radius) <= 0 then
    if ball.yspeed < 0 then
      ball.yspeed := - ball.yspeed;
  if (ball.y + ball.radius) >= Form1.image1.height then
    if ball.yspeed > 0 then
      ball.yspeed := - ball.yspeed;
end;

procedure c_balls;
var
  i, j: integer;
  a, b, c: integer;
  nrg_buf_x, nrg_buf_y: double;
begin
  for i := low(Balls) to high(Balls) do
   for j := low(Balls) to i - 1 do
      begin
        a := Balls[j].x - Balls[i].x;
        b := Balls[j].y - Balls[i].y;
        c := round(sqrt(sqr(a) + sqr(b)));
        if c <= Balls[j].radius + Balls[i].radius then
          begin
            nrg_buf_x := Balls[j].xspeed;
            nrg_buf_y := Balls[j].yspeed;
            Balls[j].xspeed := Balls[i].xspeed;
            Balls[j].yspeed := Balls[i].yspeed;
            Balls[i].xspeed := nrg_buf_x;
            Balls[i].yspeed := nrg_buf_y;
          end;
      end;
end;

procedure InitBalls;
var
  i: integer;
begin
  setlength(Balls, 10);
  for i := low(balls) to high(balls) do
    begin
      Balls[i] := TBall.Create;
      Balls[i].Radius := 7;
      Balls[i].x := i * (Balls[i].radius + 10) * 2 + Balls[i].radius + 50;
      Balls[i].y := 150;
      Balls[i].xspeed := random(11) - 5;
      Balls[i].yspeed := random(11) - 5;
      Balls[i].color := clred;
      Balls[i].Draw(form1.image1.canvas);
      Balls[i].Mass := 170;
    end;
end;

procedure MoveBalls;
var
  i: integer;
begin
  c_balls;
  for i := low(balls) to high(balls) do
    begin
      c_walls(Balls[i]);
      
      if balls[i].xspeed > 0 then
        balls[i].xspeed := balls[i].xspeed - 0.04;
      if balls[i].xspeed < 0 then
        balls[i].xspeed := balls[i].xspeed + 0.04;

      if balls[i].yspeed > 0 then
        balls[i].yspeed := balls[i].yspeed - 0.04;
      if balls[i].yspeed < 0 then
        balls[i].yspeed := balls[i].yspeed + 0.04;

      balls[i].x := balls[i].x + round(balls[i].xspeed);
      balls[i].y := balls[i].y + round(balls[i].yspeed);
    end;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  randomize;
  doublebuffered := true;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  InitBalls;
  timer1.Enabled := true;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
var
  i: integer;
begin
  image1.picture := nil;
  MoveBalls;
  for i := low(balls) to high(balls) do
    begin
      Balls[i].Draw(image1.canvas);
    end;  
end;

end.