Einfallswinkel = Ausfallswinkel :: Breakout/Pong

Übersicht

BlitzBasic

FAQ und Tutorials

	DivineDominion Betreff: Einfallswinkel = Ausfallswinkel :: Breakout/Pong	Di, März 29, 2005 21:47 Antworten mit Zitat
Hola Bürger Gibt sowas ja immer mal wieder. Daher hier mal eine Winkelversion von der Winkelberechnung. Musste selber bisschen rumprobieren, bis ich System dadrin erkannte BlitzBasic: [AUSKLAPPEN] [EINKLAPPEN] Graphics 640, 480, 0, 2 SetBuffer BackBuffer( ) Global x# = 300.0, y# = 300.0 Global angle# = Rnd( 0, 359 ) Global speed# = 5.7 While Not KeyHit( 1 ) Cls x# = x# + Cos( angle# ) * speed# y# = y# + Sin( angle# ) * speed# If y# > 480 Or y# < 0 angle# = 360 - angle# EndIf If x# < 0 Or x > 640 angle# = 180 - angle# EndIf Oval x#-5, y#-5, 10, 10, 1 Flip Wend Damit der Winkel nicht immer gleich bleibt baut man dann je nach Position des auftreffens am Schläger ne Variation ein. Soll heißen: Kommt der Ball exakt in der Mitte des Schlägers an, bleibt der Ausfallswinkel gleich dem Einfallswinkel. Trifft er auf dem ersten Viertel auf (Hälfte der ersten Hälfte ), ist der Ausfallswinkel nur halb so groß. Oder nur 3/4 so groß. Je nachdem wie man das variieren will. Rechts auf dem letzten Viertel ist er dann doppelt so groß bzw. 5/4 usw. Also Abstand zur Mitte mit einem fantasiefaktor malnehmen und dann addieren bzw subtrahieren. Denke zumindest das es so ginge
christian.tietze@gmail.com - https://christiantietze.de macOS

DivineDominion

Betreff: Einfallswinkel = Ausfallswinkel :: Breakout/Pong

Di, März 29, 2005 21:47
Antworten mit Zitat

Hola Bürger

Gibt sowas ja immer mal wieder. Daher hier mal eine Winkelversion von der Winkelberechnung. Musste selber bisschen rumprobieren, bis ich System dadrin erkannte Wink

BlitzBasic: [AUSKLAPPEN]

Graphics 640, 480, 0, 2

SetBuffer BackBuffer(  )

Global x# = 300.0, y# = 300.0
Global angle# = Rnd( 0, 359 )
Global speed# = 5.7

While Not KeyHit( 1 )
    
    Cls
        
    x# = x# + Cos( angle# ) * speed#
    y# = y# + Sin( angle# ) * speed#
    
    If y# > 480 Or y# < 0
        
        angle# = 360 - angle#
        
    EndIf
    
    If x# < 0 Or x > 640
        
        angle# = 180 - angle#
                
    EndIf
        
    Oval x#-5, y#-5, 10, 10, 1
    
    Flip
    
Wend

Damit der Winkel nicht immer gleich bleibt baut man dann je nach Position des auftreffens am Schläger ne Variation ein. Soll heißen:
Kommt der Ball exakt in der Mitte des Schlägers an, bleibt der Ausfallswinkel gleich dem Einfallswinkel.
Trifft er auf dem ersten Viertel auf (Hälfte der ersten Hälfte Smile

), ist der Ausfallswinkel nur halb so groß. Oder nur 3/4 so groß. Je nachdem wie man das variieren will. Rechts auf dem letzten Viertel ist er dann doppelt so groß bzw. 5/4 usw. Also Abstand zur Mitte mit einem fantasiefaktor malnehmen und dann addieren bzw subtrahieren.

Denke zumindest das es so ginge Smile

christian.tietze@gmail.com - https://christiantietze.de
macOS

Zuletzt bearbeitet von DivineDominion am Mi, Apr 13, 2005 16:39, insgesamt einmal bearbeitet

	BIG BUG	Mo, Apr 04, 2005 22:34 Antworten mit Zitat
Eine kleine Ergänzung: Code: [AUSKLAPPEN] [EINKLAPPEN] angle# = 2 * WallAngle# - angle# Mit dieser Formel kann man generell alle WandWinkel abfragen. WallAngle gibt dabei den Winkel der Wand an. Auf diese Formel kann man kommen, wenn man von der Regel ausgeht, daß alle Winkel in einem Dreieck in Summe immer 180 Grad ergeben.
B3D-Exporter für Cinema4D!(V1.4) MD2-Exporter für Cinema4D!(final)

BIG BUG

Mo, Apr 04, 2005 22:34
Antworten mit Zitat

Eine kleine Ergänzung:
Code: [AUSKLAPPEN]

angle# = 2 * WallAngle# - angle#

Mit dieser Formel kann man generell alle WandWinkel abfragen.
WallAngle gibt dabei den Winkel der Wand an.

Auf diese Formel kann man kommen, wenn man von der Regel ausgeht, daß alle Winkel in einem Dreieck in Summe immer 180 Grad ergeben.

B3D-Exporter für Cinema4D!(V1.4)
MD2-Exporter für Cinema4D!(final)

	Vertex	Di, Apr 12, 2005 20:25 Antworten mit Zitat
Hi! Mal als Erläuterung, wie man es mit jeder Wand machen kann: Jede Wand bekommt einen Normalvektor zugewiesen. Dieser steht im Rechtenwinkel auf jener Wand. Dann hat der Ball einen Richtungsvektor. Wenn der Ball sich mit dem Winkel α (das ist Alpha, kein "a"), sieht dieser Vektor zwangsläufig so aus: Code: [AUSKLAPPEN] [EINKLAPPEN] ---------> \| cos(α) \| \| sin(α) \| Da man sowiso für jede Schräge einen Vektor benötigt, sollte man gleich mit Types arbeiten. Da es ein 2D Spiel ist, brauchen wir auch nur 2 Komponenten -Vektoren: Code: [AUSKLAPPEN] [EINKLAPPEN] Type TVector Field X# Field Y# End Type Die Berechnung der Bewegung des Balls sieht dann so in etwa aus: Code: [AUSKLAPPEN] [EINKLAPPEN] Local Ball.TVector = New TVector Local Direction.TVector = New TVector ... Hauptschleife: Direction.X# = Cos#(Angle#)Speed# Direction.Y# = Sin#(Angle#)Speed# VectorAddition(Ball, Direction, Ball) DrawImage MyBall, Ball.X#, Ball.Y# ... Function VectorAddition(A.TVector, B.TVector, C.TVector) C.X# = A.X#+B.X# C.Y# = A.Y#+B.Y# End Function In Ball.TVector steht die X und Y Position des Balls(= Ortsvektor), in Direction die Richtung des Balls mit der Geschwindigkeit Speed. Bei VectorAddition wird dann zu der aktuellen Position des Balls die Richtung hinzu addiert. Kollidiert der Ball mit der Wand(ist schwer zu berechnen) kann man mit dem Punktprodukt herausfinden, ob der Ball vor oder hinter der Wand kollidiert ist. Was vorne und hinten der Wand ist, bestimmt der Normalvektor der Wand. Wo er hinzeigt, ist Vorne. Das Punktprodukt ist wie folgt zu bilden: Code: [AUSKLAPPEN] [EINKLAPPEN] Function VectorDotproduct#(A.TVector, B.TVector) Return A.X#B.X#+A.Y#B.Y# End Function Ist das Punktprodukt negativ, so ist der Ball hinter der Wand kollidiert. Ist es = 0.0 müsste der Ball direkt von der Seite kollidiert sein. Der Richtungsvektor wäre hier rechtwinkelig zum Normalvektor. Nun kennt ihr sicher das Strahlengesetz: Einfallswinkel = Austrittswinkel. Dieser Winkel wird in Bezug auf den Normalvektor gemessen. Wir müssen also zwischen Normalvektor und Richtungsvektor den Winekl berechnen. Dabei gilt folgende Gesetzmäßigkeit: Cos(α) = ab / (\|a\|\|b\|) Der Betrag eines Vektors x(also \|x\|) ist die Länge des Vektors. Diese ist leicht zu errechnen über Pythagoras. Erinnern wir uns c² = a²+b² bzw. c = Sqr(a²+b²). Man geht einfach davon aus, das der Vektor am Koordinatenursprung(= 0, 0) liegt, und somit ein rechtwinkeliges Dreieck zur X und Y Achse bildet. Der X Abstand zum koordinatenursprung ist Kathete A und der Y Abstand Kathete B. Somit ist \|x\| = Sqr(x.x²+x.y²) Code: [AUSKLAPPEN] [EINKLAPPEN] Function VectorLength#(V.TVector) Return Sqr#(V.X#V.X# + V.Y#V.Y#) End Function Über das Punktprodukt können wir wieder 2 Vektoren miteinander multiplizieren. Also ist Cos(α) = VectorDotproduct(Direction, Normal)/(VectorLength(Direction)VectorLength(Normal)) bzw.: α = ACos(VectorDotproduct(Direction, Normal)/(VectorLength(Direction)VectorLength(Normal))) ACos steht für ArcusCosinus. Arcus heißt sowei ich das noch weiß, Bogen auf Deutsch. Es ist die Umkehrfunktion von Cosinus. α = ACos(Cos(α)) Jetzt haben wir den Einfallswinkel Man müsste nun noch den Winkel des Bormalvektors erechnen, davon die Differenz zum Einfallswinkel bilden, diese Differenz zum WInkel des Normalvektors addieren und diesen neuen WInkel beim Berechnen von Vektor Direction einsetzen. Bin jetzt aber zu faul dazu Sorry, das ich keine Bilder gemacht hatte. mfg olli
vertex.dreamfall.at \| GitHub

Vertex

Di, Apr 12, 2005 20:25
Antworten mit Zitat

Hi!
Mal als Erläuterung, wie man es mit jeder Wand machen kann:
Jede Wand bekommt einen Normalvektor zugewiesen. Dieser steht im Rechtenwinkel auf jener Wand.

Dann hat der Ball einen Richtungsvektor. Wenn der Ball sich mit dem Winkel α (das ist Alpha, kein "a"), sieht dieser Vektor zwangsläufig so aus:
Code: [AUSKLAPPEN]

--------->

| cos(α) |
| sin(α) |

Da man sowiso für jede Schräge einen Vektor benötigt, sollte man gleich mit Types arbeiten. Da es ein 2D Spiel ist, brauchen wir auch nur 2 Komponenten -Vektoren:
Code: [AUSKLAPPEN]

Type TVector
Field X#
Field Y#
End Type

Die Berechnung der Bewegung des Balls sieht dann so in etwa aus:
Code: [AUSKLAPPEN]

Local Ball.TVector = New TVector
Local Direction.TVector = New TVector

...

Hauptschleife:
Direction.X# = Cos#(Angle#)*Speed#
Direction.Y# = Sin#(Angle#)*Speed#

VectorAddition(Ball, Direction, Ball)
DrawImage MyBall, Ball.X#, Ball.Y#
...

Function VectorAddition(A.TVector, B.TVector, C.TVector)
C.X# = A.X#+B.X#
C.Y# = A.Y#+B.Y#
End Function

In Ball.TVector steht die X und Y Position des Balls(= Ortsvektor), in Direction die Richtung des Balls mit der Geschwindigkeit Speed. Bei VectorAddition wird dann zu der aktuellen Position des Balls die Richtung hinzu addiert.

Kollidiert der Ball mit der Wand(ist schwer zu berechnen) kann man mit dem Punktprodukt herausfinden, ob der Ball vor oder hinter der Wand kollidiert ist. Was vorne und hinten der Wand ist, bestimmt der Normalvektor der Wand. Wo er hinzeigt, ist Vorne.

Das Punktprodukt ist wie folgt zu bilden:
Code: [AUSKLAPPEN]

Function VectorDotproduct#(A.TVector, B.TVector)
Return A.X#*B.X#+A.Y#*B.Y#
End Function

Ist das Punktprodukt negativ, so ist der Ball hinter der Wand kollidiert. Ist es = 0.0 müsste der Ball direkt von der Seite kollidiert sein. Der Richtungsvektor wäre hier rechtwinkelig zum Normalvektor.

Nun kennt ihr sicher das Strahlengesetz: Einfallswinkel = Austrittswinkel. Dieser Winkel wird in Bezug auf den Normalvektor gemessen. Wir müssen also zwischen Normalvektor und Richtungsvektor den Winekl berechnen. Dabei gilt folgende Gesetzmäßigkeit:
Cos(α) = a*b / (|a|*|b|)

Der Betrag eines Vektors x(also |x|) ist die Länge des Vektors. Diese ist leicht zu errechnen über Pythagoras. Erinnern wir uns c² = a²+b² bzw. c = Sqr(a²+b²). Man geht einfach davon aus, das der Vektor am Koordinatenursprung(= 0, 0) liegt, und somit ein rechtwinkeliges Dreieck zur X und Y Achse bildet. Der X Abstand zum koordinatenursprung ist Kathete A und der Y Abstand Kathete B. Somit ist |x| = Sqr(x.x²+x.y²)
Code: [AUSKLAPPEN]

Function VectorLength#(V.TVector)
Return Sqr#(V.X#*V.X# + V.Y#*V.Y#)
End Function

Über das Punktprodukt können wir wieder 2 Vektoren miteinander multiplizieren.

Also ist Cos(α) = VectorDotproduct(Direction, Normal)/(VectorLength(Direction)*VectorLength(Normal)) bzw.:
α = ACos(VectorDotproduct(Direction, Normal)/(VectorLength(Direction)*VectorLength(Normal)))

ACos steht für ArcusCosinus. Arcus heißt sowei ich das noch weiß, Bogen auf Deutsch. Es ist die Umkehrfunktion von Cosinus. α = ACos(Cos(α))

Jetzt haben wir den Einfallswinkel Smile

Man müsste nun noch den Winkel des Bormalvektors erechnen, davon die Differenz zum Einfallswinkel bilden, diese Differenz zum WInkel des Normalvektors addieren und diesen neuen WInkel beim Berechnen von Vektor Direction einsetzen. Bin jetzt aber zu faul dazu Smile

Sorry, das ich keine Bilder gemacht hatte.

mfg olli

vertex.dreamfall.at | GitHub

	Markus Rossé	Di, Apr 12, 2005 21:02 Antworten mit Zitat
Noch einbisschen mehr Theorie: http://www.thewall.de/forum/sh...adid=31203 cu, Markus Rossé

Markus Rossé

Di, Apr 12, 2005 21:02
Antworten mit Zitat

Noch einbisschen mehr Theorie:

http://www.thewall.de/forum/sh...adid=31203

cu, Markus Rossé

	krux	Mi, Aug 31, 2005 19:26 Antworten mit Zitat
soory ich hab mir garnichts durchgelesen ausser titel aber kann man nicht einfach bei horrizuntaler berührung die x bewegung umdrehen und umgekehrt, was anderes kibts doch sowiso nicht

krux

Mi, Aug 31, 2005 19:26
Antworten mit Zitat

soory ich hab mir garnichts durchgelesen ausser titel aber kann man nicht einfach bei horrizuntaler berührung die x bewegung umdrehen und umgekehrt, was anderes kibts doch sowiso nicht

	Klip	Mi, Aug 31, 2005 20:05 Antworten mit Zitat
Wenn du das machst, dann fliegt der Ball immer gleich weg, egal ob du mit der Kante des Schlägers oder der Mitte triffst. Programmier es doch mal so einfach. Wird nicht viel Spaß machen, da man schon vor dem Aufprall weiß, wo der Ball hinfliegen wird (sehr öde).

Klip

Mi, Aug 31, 2005 20:05
Antworten mit Zitat

Wenn du das machst, dann fliegt der Ball immer gleich weg, egal ob du mit der Kante des Schlägers oder der Mitte triffst.

Programmier es doch mal so einfach. Wird nicht viel Spaß machen, da man schon vor dem Aufprall weiß, wo der Ball hinfliegen wird (sehr öde).

	BlitzBasic303 Betreff: RE:	Mi, Okt 19, 2005 20:16 Antworten mit Zitat
Ich habe ein kleines Problem damit: Ich möchte ein Minigolfspiel proggen. die Wände mach ich mit Images. wenn der Ball jetzt von links oder rechts kommt, prallt er so ab wie er soll. kommt er aber von unten oder unten ,rollt der ball auf dem Bild. Wie behebe ich das Problem?

BlitzBasic303

Betreff: RE:

Mi, Okt 19, 2005 20:16
Antworten mit Zitat

Ich habe ein kleines Problem damit:

Ich möchte ein Minigolfspiel proggen. die Wände mach ich mit Images. wenn der Ball jetzt von links oder rechts kommt, prallt er so ab wie er soll. kommt er aber von unten oder unten ,rollt der ball auf dem Bild.

Wie behebe ich das Problem?

	Spikespine	Do, Okt 20, 2005 16:34 Antworten mit Zitat
Du solltest nach dem prüfen, ob eine Koordinate kleiner als 0 bzw. größer als die Auflösung, x# bzw. y# auf diesen Wert setzen. z.B. BlitzBasic: [AUSKLAPPEN] [EINKLAPPEN] If x# < 0 Then x# = 0 ;Winkel EndIf
Athlon 64 3700+ \| 1024 MB RAM \| GeForce 7900 GT \| Blitz2D, Blitz3D, BlitzPlus, BlitzMax

Spikespine

Do, Okt 20, 2005 16:34
Antworten mit Zitat

Du solltest nach dem prüfen, ob eine Koordinate kleiner als 0 bzw. größer als die Auflösung, x# bzw. y# auf diesen Wert setzen.

z.B.

BlitzBasic: [AUSKLAPPEN]

If x# < 0 Then
 x# = 0
 ;Winkel
EndIf

Athlon 64 3700+ | 1024 MB RAM | GeForce 7900 GT | Blitz2D, Blitz3D, BlitzPlus, BlitzMax