4 Dimensionale Kollisionsabfrage von Shapes

[SpiDe1500]

Hallo, ich bräuchte eine 4 Dimensionale Kollisionsabfrage von Shapes. Das heißt, der Ball soll Shapes erkennen, und zwar egal von wo er auf das Shape kommt und zurückspringen.

Bisher sieht das ganze so aus:

Zitat:

procedure TForm1.Timer1Timer(Sender: TObject);
begin
//Rechte Shape Seite
if (ball.left < shape29.Left + shape29.width) and
(not (ball.top + ball.Height < shape29.top)) and
(not (ball.Top > shape29.top + shape29.height)) and
(not (ball.Left + ball.Width/2 < shape29.Left + shape29.Width/2))
then begin
timer2.Enabled := true;
hoch := false;
runter := false;
links := false;
rechts := true; end;

//Linke Shape Seite
if (ball.Left + ball.Width > shape29.Left) and
(not (ball.top + ball.Height < shape29.top)) and
(not (ball.Top > shape29.top + shape29.height)) and
(not (ball.Left + ball.Width/2 > shape29.Left + shape29.Width/2))
then begin
timer2.Enabled := true;
hoch := false;
runter := false;
links := true;
rechts := false;
end;

//Untere Shape Seite
if (ball.Top < shape29.Top + shape29.Height) and
(not (ball.Left < shape29.Left)) and
(not (ball.Left + ball.width > shape29.Left + shape29.Width)) and
(not (ball.Top + ball.Height/2 < shape29.Top + shape29.Height/2))
then begin
timer2.Enabled := true;
hoch := false;
runter := true;
links := false;
rechts := false;
end;
//Obere Shape Seite
if(ball.Top + ball.Height > shape29.Top) and
(not (ball.Left < shape29.left)) and
(not (ball.Left + ball.Width > shape29.Left + shape29.width)) and
(not (ball.Top + ball.Height/2 > shape29.Top + shape29.Height/2))
then begin
timer2.Enabled := true;
hoch := true;
runter := false;
links := false;
rechts := false;
end;
end;
procedure TForm1.Timer2Timer(Sender: TObject);
begin
if links = true then begin
ball.left := ball.Left - 10;
links := false;
end;
if rechts = true then begin
ball.Left := ball.left + 10;
rechts := false;
end;
if hoch = true then begin
ball.Top := ball.top - 10;
hoch := false;
end;
if runter = true then begin
ball.Top := ball.top + 10;
runter := false;
end;
end;

end.

funktionieren tuts allerdings kein bisschen

Hat da vllt jmd was fertiges, was man kopieren könnte?
Ich brauche das ganze für ein Ballspiel... werde dann auch das Ergebnis hier präsentieren
Es wäre sehr gut, wenn ich das Ergebnis hier bis Morgen abend hätte, da ich das ganze für eine Präsi brauche und ohne ein bisschen aufgescmissen bin bzw improvisieren müsste.... also... biiiittte biiittte bittte *lieb guck*

Über jede hilfe wäre ich sehr dankbar!

[Namenloser]

Deine Shapes sind vierdimensional? Kommst du aus der Zukunft? Wow, hätte nicht gedacht, dass es im Jahr 3000 noch Delphi gibt...

[SpiDe1500]

War klar, dass das kommt

Warum vllt doof ausgedrückt...

ich meine, dass die Shapes von allen seiten erkannt werden können... logisch ?

Also oben unten links und rechts

4D kann mein Delphi nur, wenn ich vorher ganz viel getrunken habe... oeh... egal

Wir könnten das ganze auch unter "vollständiger" 2D Kollisionsabfrage abhandeln ich denke damit weiß jeder, was gemeint ist
eine einseitige für ein Ping Pong projekt habe ich schon erfolgreich geschrieben, mit winkeln und allem drum und dran (ist ja nun weißgott nicht schwer...) jedoch verzweilfe ich an der 4seitigen abfrage, da nicht eine abfrage auch nur einen fehler enthalten darf, da sonst alles den bach runtergeht und man überhaupt nicht mehr weiß wo überhaupt der fehler liegt... ((

Dh. die frage, ob vllt jmd was fertiges rumliegen hat oder die güte hat, mal kurz rüber zu schaun

[Aphton]

Die vierte Dimension entsteht, wenn man Raum mit Raum kreuzt!

@Threadstarter
Warum so umständlich und konkret? Ersten würde ich dir anraten, die Kollisionsabfrage in eine Funktion auszulagern um beliebige (Shape-)Objekte darauf prüfen zu können.
Weiters würde ich ne eigene Klasse definieren, die die Eigenschaften Position (P), Geschwindigkeit (V), und Masse (M) hat um anschließend Folgendes anwenden zu können:

http://upload.wikimedia.org/math/4/4...c718480f9f.png
http://upload.wikimedia.org/math/c/4...5408adf464.png

(Quelle)

[SpiDe1500]

Hallo,

schonmal danke für die Antworten.

Ich bin absoluter Anfänger in Delphi (gerade ein bisschen mehr als ein halbes Jahr dabei... mal mehr und mal weniger ...).

Ich weiß zwar was eine Klasse ist, bin aber noch ein wenig davon entfernt eine solche zu programmieren.
Schon gar nicht mit solch einer Mathematischen Formel Aber danke für die Hilfe!

Eine Funktion auszulagern... das könnte ich durchaus, wäre dann halt ein Process abruf, wenn ich nicht irre.


Aber was gewinne ich dadurch? Ich muss doch für jeden Shape einen Process schreiben und in jedem Process muss wieder die gesamte Kollisionsabfrage des Shapes, oder? Könnte man das auch vereinfachen?
Wie gesagt, entschuldigt die doofen fragen.
Was gewinne ich dadurch denn ? Der Quellcode wird nicht unbedingt kürzer (eher ein biscshen länger) - nur die Übersichtlichkeit gewinnt ein wenig dazu...

Danke für jede Antwort!

[Aphton]

Deine letzte Aussage ist widersprüchlich. Sobald du es in eine Funktion auslagerst - wobei eine Funktion <> Prozess (Win32 Prozess?) - musst du nur die Funktion mit den Shape Parametern aufrufen und prüfen, ob die Funktion als Rückgabewert True liefert (in diesem Fall).

Dadurch musst du das ganze nicht für jedes Shapeobjekt konkret ausprogrammieren, sondern kannst es abstrakt für alle Shapes machen und es dann bei beliebig vielen Shapes ausführen.

Am besten wäre es an diesem Punkt zu lernen, was bzw. wie Functions/Procedures in Delphi funktionieren. Ich bin ein totaler Anfänger ist keine Entschuldigung, informiere dich darüber!

[Namenloser]

Erklär mal bitte die Rahmenbedinungen etwas genauer. Bewegen sich die Shapes und sollen von anderen Shapes "reflektiert" werden, oder wie?

[SpiDe1500]

Danke schonmal, hast schon Recht mit der Funktion.Dachte mir schon, dass Delphi da irgendiwe eine vereinfachung anbieten muss... Hatte jetzt an einen Process gedacht, aber das ist ja wieder was anderes innerhalb Delphis. Und würde das ganze eher verkomplexizieren.

Werde mir das ganze mal genauer anschauen.

Prinzipell ist es so, dass ein Ball von allen Seiten auf eine Shape treffen kann und dann korrekt von dieser Reflektiert werden soll!

Wichtig ist: es gibt viele solcher Shapes, die sich unter umständen auch bewegen (wenn das gehen sollte... ist kein muss) - aber das ist ja sicherlich nicht das problem...

Bisher habe ich das nur für eine Seite programmiert (für Pong braucht man ja nunmal nicht mehr...) - dort ging es nach einiger Programmier und Austestarbeit auch wunderbar, auch mit Winkeln, wie gesagt.

Nun habe ich aber beim PingPong gemerkt, wie extrem unsauber und kompliziert ich gearbeitet habe.

Werde nun defintiv alles dran setzen das ganze mit einer Funktion zu lösen, auch wenn ich selbst noch nie eine solche erstellt habe, gibt sicherlich genug informkationen im Welt weiten Web

Über Lösungsansätze (!) würde ich mich freuen, gern auch mit Links - aber nur, wenn es nicht zuviel arbeit bereitet, lernen tue ich nur autodidaktisch, dh selbsterfahrend, Code kopieren und einfügen, den man nicht versteht, halte ich für völligen Nonesense ...

Danke schonmal an alle, hoffe ich nerve nicht zu sehr

[Namenloser]

Ich würde zunächst mal die Boolean-Variablen Hoch, Runter, Links und Rechts ersetzen durch einen Geschwindigkeitsvektor, z.B. Velocity (TPoint eignet sich hier, wenn du mit Integern arbeitest).

Die Bewegungsroutine vereinfacht sich nun, indem du nur noch schreiben musst:

Delphi-Quellcode:

Shape.Left := Shape.Left+Velocity.X;
Shape.Top := Shape.Top+Velocity.Y;

Je nachdem, ob die X-/Y-Komponenten von Velocity positiv oder negativ sind, geht es dann eben nach rechts oder links bzw. unten oder oben.

In der Kollisionsroutine prüfst du dann mithilfe des Geschwindigkeitsvektors und der Positionsdaten für die X- und Y-Richtung getrennt, ob die Shapes sich aufeinander zu, oder voneinander weg bewegen. Wenn sie sich aufeinander zu bewegen, drehst du das Vorzeichen für die jeweilige Geschwindigkeitskomponente um.

Wenn man hier davon ausgeht, dass ShapeA sich bewegt und ShapeB fest ist, könnte man es so machen:

Delphi-Quellcode:

var
  Collision: Boolean;
  R: TRect;
begin
  // Prüfen, ob Shapes sich schneiden mithilfe von IntersectRect
  Collision := IntersectRect(
    Bounds(ShapeA.Left, ShapeA.Top, ShapeA.Width, ShapeA.Height),
    Bounds(ShapeB.Left, ShapeB.Top, ShapeB.Width, ShapeB.Height), 
    R
  );
  if Collision then
  begin
     // X-Richtung umkehren?
     if (// Mittelpunkt von ShapeA rechts von Mittelpunkt von ShapeB
         (ShapeA.Left+ShapeA.Width div 2 > ShapeB.Left+ShapeB.Width div 2) and
         // und ShapeA bewegt sich nach links -> Bewegt sich auf ShapeB zu
         (ShapeA.Velocity.X < 0)
        ) or
        (// Mittelpunkt von ShapeA links von Mittelpunkt von ShapeB
         (ShapeA.Left+ShapeA.Width div 2 < ShapeB.Left+ShapeB.Width div 2) and
         // und ShapeA bewegt sich nach rechts -> Bewegt sich auf ShapeB zu
         (ShapeA.Velocity.X > 0)
        ) then
     begin
       ShapeA.Velocity.X := -ShapeA.Velocity.X;
     end;
     // Y-Richtung umkehren?
     if (// Mittelpunkt von ShapeA unterhalb von Mittelpunkt von ShapeB
         (ShapeA.Top+ShapeA.Height div 2 > ShapeB.Top+ShapeB.Height div 2) and
         // und ShapeA bewegt sich nach oben -> Bewegt sich auf ShapeB zu
         (ShapeA.Velocity.Y < 0)
        ) or
        (// Mittelpunkt von ShapeA oberhalb von Mittelpunkt von ShapeB
         (ShapeA.Top+ShapeA.Height div 2 < ShapeB.Top+ShapeB.Height div 2) and
         // und ShapeA bewegt sich nach oben -> Bewegt sich auf ShapeB zu
         (ShapeA.Velocity.Y > 0)
        ) then
     begin
       ShapeA.Velocity.Y := -ShapeA.Velocity.Y;
     end;
  end;
end;

Achtung: ShapeA.Velocity.X habe ich hier dazu erfunden. Die Property gibt es nicht, musst du dir überlegen, wie du diese Information speicherst. Am besten wäre es, wenn du für deine Objekte gleich eine eigene Klasse deklarieren würdest.

[Bummi]

Wenn der Ball wirklich rund sein soll kannst Du auch mit Regions arbeiten ...

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TPArray=Array[0..4] of TPoint;

  TForm1 = class(TForm)
    Image1: TImage;
    Button1: TButton;
    Panel1: TPanel;
    procedure Button1Click(Sender: TObject);
  private
    Figure1:TPArray;
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  FigReg,CircleReg:HRGN;
begin
    Figure1[0].X := 0;
    Figure1[0].Y := 0;
    Figure1[1].X := 50;
    Figure1[1].Y := 0;
    Figure1[2].X := 50;
    Figure1[2].Y := 50;
    Figure1[3].X := 25;
    Figure1[3].Y := 75;
    Figure1[4].X := 0;
    Figure1[4].Y := 50;
    FigReg := CreatePolygonRgn(Figure1,5,WINDING);
    CircleReg := CreateEllipticRgn(30,30,100,100);
    if not (CombineRgn(FigReg,FigReg,CircleReg,RGN_AND)=NULLREGION)
     then Showmessage('Collision');
    SetWindowrgn(Panel1.Handle,FigReg,true); // Anzeige des Ergebnisses
    Deleteobject(FigReg);
    Deleteobject(CircleReg);
end;
end.

wobei Du beiliegendes Beispiel vereinfachen kannst....