Physik Engine Projekt

moritz1243

Hi zusammen,

hätte jemand Lust mit mir eine Physik-Engine zu schreiben? Sie soll erstmal "nur" Kreise und Polygone ohne Schwerkraft berechnen, sprich Kollision(habe ich schon größtenteils fertig und dann die energie übertragung (Bewegungsvektoren und Rotationsgeschwindigkeit).

Hier schonmal was ich geschaft habe:

Spoiler anzeigen

[autoit]

#include <GuiConstants.au3>
#include <GDIPlus.au3>
#include <Misc.au3>
#include <Mathe.au3>
#include <Array.au3>

[/autoit] [autoit][/autoit] [autoit]

HotKeySet("{ESC}", "_beenden")

[/autoit] [autoit][/autoit] [autoit]

Opt('MustDeclareVars', 1)
Opt('GuiOnEventMode', 1)
Opt ('MouseCoordMode', 0 )

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Global $hGUI, $hWnd, $hGraphic, $Bitmap, $Buffer, $hPen, $msg
Global $width = 640
Global $height = 400
Global $titel = "Titel"
Global $version = " v XXX"

[/autoit] [autoit][/autoit] [autoit]

Global Const $pi = 3.14159265358979
Global Const $pi_div_180 = $pi/180
Global Const $180_div_pi = 180/$pi

[/autoit] [autoit][/autoit] [autoit]

Global $Kugel_Masse
Global $Kugel_Radius
Global $Kugel_Position
Global $Kugel_Vector

[/autoit] [autoit][/autoit] [autoit]

Global $Kugel_Reibung = 0.0

[/autoit] [autoit][/autoit] [autoit]

Global $mov[2]

[/autoit] [autoit][/autoit] [autoit]

#Region Kugel hinzufügen
Func Kugel_Hinzufuegen($x, $y, $radius, $x_vector = 0, $y_vector = 0, $masse = 0)

If IsArray($Kugel_Masse) Then
Local $Element = UBound($Kugel_Masse)
ReDim $Kugel_Masse[$Element+1]
ReDim $Kugel_Radius[$Element+1]
ReDim $Kugel_Position[$Element+1][2]
ReDim $Kugel_Vector[$Element+1][2]
Else
Local $Element = 0
Dim $Kugel_Masse[$Element+1]
Dim $Kugel_Radius[$Element+1]
Dim $Kugel_Position[$Element+1][2]
Dim $Kugel_Vector[$Element+1][2]
EndIf

[/autoit] [autoit][/autoit] [autoit]

$Kugel_Radius[$Element] = $radius
If $masse = 0 Then
$Kugel_Masse[$Element] = $PI * $radius * $radius
Else
$Kugel_Masse[$Element] = $masse
EndIf
$Kugel_Position[$Element][0] = $x
$Kugel_Position[$Element][1] = $y
If _Punkte_Distance($x,$y,$x+$x_vector,$y+$y_vector) <> 0 Then
$Kugel_Vector[$Element][0] = $x_vector; / _Punkte_Distance($x,$y,$x+$x_vector,$y+$y_vector)
Else
$Kugel_Vector[$Element][0] = 0
EndIf
If _Punkte_Distance($x,$y,$x+$x_vector,$y+$y_vector) <> 0 Then
$Kugel_Vector[$Element][1] = $y_vector; / _Punkte_Distance($x,$y,$x+$x_vector,$y+$y_vector)
Else
$Kugel_Vector[$Element][1] = 0
EndIf

[/autoit] [autoit][/autoit] [autoit]

EndFunc
#EndRegion
Kugel_Hinzufuegen(100, 100, 20, 10, 9)
Kugel_Hinzufuegen(200, 100, 20, -8, 10)

[/autoit] [autoit][/autoit] [autoit]

Global $Strich[1][4]
#Region Strich hinzufügen
Func Strich_Hinzufuegen($x1,$y1, $x2,$y2)

Local $Strich_Anzahl = UBound($Strich)

ReDim $Strich[$Strich_Anzahl+1][4]

$Strich[$Strich_Anzahl][0] = $x1
$Strich[$Strich_Anzahl][1] = $y1
$Strich[$Strich_Anzahl][2] = $x2
$Strich[$Strich_Anzahl][3] = $y2

EndFunc
#EndRegion

[/autoit] [autoit][/autoit] [autoit]

$hGUI = GUICreate($Titel & $version, $width, $height,-1,-1)
GUISetOnEvent($GUI_EVENT_CLOSE, "_beenden")
$hWnd = WinGetHandle($Titel & $version)
GUISetState(@SW_SHOW)

[/autoit] [autoit][/autoit] [autoit]

Global $Quadrat
#Region Quadrat hinzufügen
Func Rechteck_Hinzufuegen($x, $y, $breite, $hoehe)

[/autoit] [autoit][/autoit] [autoit]

If IsArray($Quadrat) Then
Local $Quadrat_Anzahl = UBound($Quadrat)
ReDim $Quadrat[$Quadrat_Anzahl+1][8]
Else
Local $Quadrat_Anzahl = 0
Dim $Quadrat[$Quadrat_Anzahl+1][8]
EndIf

$Quadrat[$Quadrat_Anzahl][0] = $x
$Quadrat[$Quadrat_Anzahl][1] = $y
$Quadrat[$Quadrat_Anzahl][2] = $x + $breite
$Quadrat[$Quadrat_Anzahl][3] = $y
$Quadrat[$Quadrat_Anzahl][4] = $x + $breite
$Quadrat[$Quadrat_Anzahl][5] = $y + $hoehe
$Quadrat[$Quadrat_Anzahl][6] = $x
$Quadrat[$Quadrat_Anzahl][7] = $y + $hoehe

[/autoit] [autoit][/autoit] [autoit]

EndFunc
#EndRegion
Rechteck_Hinzufuegen(100, 300, 100, 60)

[/autoit] [autoit][/autoit] [autoit]

GUISetCursor(16) ;unsichtbar

[/autoit] [autoit][/autoit] [autoit]

Global $Aktuelle_Kugel = 0
Global $Richtung
Global $Geschwindigkeit

[/autoit] [autoit][/autoit] [autoit]

_GDIPlus_Startup ()

[/autoit] [autoit][/autoit] [autoit]

$hGraphic = _GDIPlus_GraphicsCreateFromHWND ($hWnd)
$Bitmap = _GDIPlus_BitmapCreateFromGraphics($width, $height, $hGraphic)
$Buffer = _GDIPlus_ImageGetGraphicsContext($Bitmap)
_GDIPlus_GraphicsSetSmoothingMode($Buffer, 4)
_GDIPlus_GraphicsClear($Buffer,0xFF000000)
$hPen = _GDIPlus_PenCreate (0xFF00FF00,1)

[/autoit] [autoit][/autoit] [autoit]

AdlibEnable("Main", 25)

[/autoit] [autoit][/autoit] [autoit]

While 1
Sleep(3000)
WEnd

[/autoit] [autoit][/autoit] [autoit]

Func Main()
_GDIPlus_GraphicsClear($Buffer,0xFFFFFFFF)
Input()
Kugeln()
Zeichnen()

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Input()

_GDIPlus_GraphicsFillRect($Buffer,MouseGetPos(0),MouseGetPos(1)-25,4,4)

If _IsPressed(01) Then

Local $mouse_position = MouseGetPos()

For $i = 0 To UBound($Kugel_Position)-1 Step 1

If _Punkte_Distance($mouse_position[0], $mouse_position[1]-25, $Kugel_Position[$i][0] + $Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i]) < $Kugel_Radius[$i] Then

$Aktuelle_Kugel = $i
ExitLoop

EndIf

Next
EndIf
If $Aktuelle_Kugel <> -1 Then
If _IsPressed(02) Then
Local $mouse_position = MouseGetPos()
$Kugel_Position[$Aktuelle_Kugel][0] = $mouse_position[0] - 25
$Kugel_Position[$Aktuelle_Kugel][1] = $mouse_position[1] - 50
EndIf
EndIf
If $Aktuelle_Kugel <> -1 Then

$mov[0] = 0
$mov[1] = 0

If _IsPressed(41) Then
$Richtung += 5;$mov[0] += 10;$Kugel_Vector[$Aktuelle_Kugel][0] += 0.5
RechtEck_drehen(0, 5)
ElseIf _IsPressed(44) Then
$Richtung -= 5;$mov[0] -= 10;$Kugel_Vector[$Aktuelle_Kugel][0] -= 0.5
RechtEck_drehen(0, -5)
EndIf
If _IsPressed(53) And $Geschwindigkeit < 10 Then $Geschwindigkeit += 0.5;$mov[1] += 10;$Kugel_Vector[$Aktuelle_Kugel][1] += 0.5
If _IsPressed(57) And $Geschwindigkeit > -10 Then $Geschwindigkeit -= 0.5;$mov[1] -= 10;$Kugel_Vector[$Aktuelle_Kugel][1] -= 0.5
EndIf

[/autoit] [autoit][/autoit] [autoit]

$mov[0] = Sin(($Richtung+90)*$pi_div_180)*$Geschwindigkeit
$mov[1] = Cos(($Richtung+90)*$pi_div_180)*$Geschwindigkeit

RechtEck_Bewegen(0,$mov[0],$mov[1])

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func RechtEck_Bewegen($ID,$x,$y)

For $i = 0 To 7 Step 2
If $Quadrat[$ID][$i] + $x < 0 Or $Quadrat[$ID][$i] + $x > $width Then Return 0
If $Quadrat[$ID][$i+1] + $y < 0 Or $Quadrat[$ID][$i+1] + $y > $height Then Return 0
Next

[/autoit] [autoit][/autoit] [autoit]

For $i = 0 To 7 Step 2

$Quadrat[$ID][$i] += $x
$Quadrat[$ID][$i+1] += $y

Next

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func RechtEck_drehen($ID, $Winkel)

[/autoit] [autoit][/autoit] [autoit]

Local $Center[2] = [($Quadrat[$ID][0]+$Quadrat[$ID][4])/2, ($Quadrat[$ID][1]+$Quadrat[$ID][5])/2]

[/autoit] [autoit][/autoit] [autoit]

For $i = 0 To 7 Step 2

Local $Winkel_Alt = _Punkte_Winkel($Center[0],$Center[1], $Quadrat[$ID][$i], $Quadrat[$ID][$i+1]) + 90
Local $Abstand = _Punkte_Distance($Center[0],$Center[1], $Quadrat[$ID][$i], $Quadrat[$ID][$i+1])

$Quadrat[$ID][$i] = $Center[0] + Sin(($Winkel_Alt + $Winkel)*$pi_div_180)*$Abstand
$Quadrat[$ID][$i+1] = $Center[1] + Cos(($Winkel_Alt + $Winkel)*$pi_div_180)*$Abstand
Next

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Kugeln()

Kugeln_Bewegen()
Kugeln_Kollisionen()

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Kugeln_Bewegen()

Local $limit = 10

For $i = 0 To UBound($Kugel_Position)-1 Step 1

$Kugel_Position[$i][0] += $Kugel_Vector[$i][0]
$Kugel_Position[$i][1] += $Kugel_Vector[$i][1]

If Abs($Kugel_Vector[$i][0]) < $Kugel_Reibung Then $Kugel_Vector[$i][0] = 0
If Abs($Kugel_Vector[$i][1]) < $Kugel_Reibung Then $Kugel_Vector[$i][1] = 0

If $Kugel_Vector[$i][0] < 0 Then
$Kugel_Vector[$i][0] += $Kugel_Reibung
ElseIf $Kugel_Vector[$i][0] > 0 Then
$Kugel_Vector[$i][0] -= $Kugel_Reibung
EndIf
If $Kugel_Vector[$i][1] < 0 Then
$Kugel_Vector[$i][1] += $Kugel_Reibung
ElseIf $Kugel_Vector[$i][1] > 0 Then
$Kugel_Vector[$i][1] -= $Kugel_Reibung
EndIf

If Abs($Kugel_Vector[$i][0]) > $limit Then
Local $divisor = Abs($Kugel_Vector[$i][0]) / $limit
$Kugel_Vector[$i][0] /= $divisor
$Kugel_Vector[$i][1] /= $divisor
EndIf
If Abs($Kugel_Vector[$i][1]) > $limit Then
Local $divisor = Abs($Kugel_Vector[$i][1]) / $limit
$Kugel_Vector[$i][0] /= $divisor
$Kugel_Vector[$i][1] /= $divisor
EndIf
Next

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Kugeln_Kollisionen()

[/autoit] [autoit][/autoit] [autoit]

Local $Kugel_Anzahl = UBound($Kugel_Position)

For $i = 0 To $Kugel_Anzahl-1 Step 1
For $j = $i+1 To $Kugel_Anzahl-1 Step 1

If _Punkte_Distance($Kugel_Position[$i][0], $Kugel_Position[$i][1], $Kugel_Position[$j][0], $Kugel_Position[$j][1]) < $Kugel_Radius[$i] + $Kugel_Radius[$j] Then

[/autoit] [autoit][/autoit] [autoit]

Local $Delta_X = $Kugel_Position[$i][0] - $Kugel_Position[$j][0]
Local $Delta_Y = $Kugel_Position[$i][1] - $Kugel_Position[$j][1]
Local $Abstand = Sqrt($Delta_X*$Delta_X+$Delta_Y*$Delta_Y)

Local $Matrix11 = $Delta_X / $Abstand
Local $Matrix12 = -$Delta_Y / $Abstand
Local $Matrix21 = $Delta_Y / $Abstand
Local $Matrix22 = $Delta_X / $Abstand

[/autoit] [autoit][/autoit] [autoit]

;$Koordinatentransformion

Local $Vp1 = $Kugel_Vector[$i][0] * $Matrix11 + $Kugel_Vector[$i][1] * -$Matrix12
Local $Vs1 = $Kugel_Vector[$i][0] * -$Matrix21 + $Kugel_Vector[$i][1] * $Matrix22
Local $Vp2 = $Kugel_Vector[$j][0] * $Matrix11 + $Kugel_Vector[$j][1] * -$Matrix12
Local $Vs2 = $Kugel_Vector[$j][0] * -$Matrix21 + $Kugel_Vector[$j][1] * $Matrix22

If $Vp1-$Vp2<0 Then

Local $MasseTotal = $Kugel_Masse[$i] + $Kugel_Masse[$j]
Local $Vp1_ = ($Kugel_Masse[$i]-$Kugel_Masse[$j]) / $MasseTotal * $Vp1 + 2*$Kugel_Masse[$j] / $MasseTotal * $Vp2
Local $Vp2_ = ($Kugel_Masse[$j]-$Kugel_Masse[$i]) / $MasseTotal * $Vp2 + 2*$Kugel_Masse[$i] / $MasseTotal * $Vp1

[/autoit] [autoit][/autoit] [autoit]

$Kugel_Vector[$i][0] = $Vp1_ * $Matrix11+$Vs1*$Matrix12
$Kugel_Vector[$i][1] = $Vp1_ * $Matrix21+$Vs1*$Matrix22
$Kugel_Vector[$j][0] = $Vp2_ * $Matrix11+$Vs2*$Matrix12
$Kugel_Vector[$j][1] = $Vp2_ * $Matrix21+$Vs2*$Matrix22

EndIf

EndIf
Next

If $Kugel_Position[$i][0] <= 0 Or $Kugel_Position[$i][0] + $Kugel_Radius[$i]*2 >= $width Then
$Kugel_Vector[$i][0] = -$Kugel_Vector[$i][0]
If $Kugel_Position[$i][0] <= 0 Then
$Kugel_Position[$i][0] = 0
Else
$Kugel_Position[$i][0] = $width - 2*$Kugel_Radius[$i]
EndIf
EndIf
If $Kugel_Position[$i][1] <= 0 Or $Kugel_Position[$i][1] + $Kugel_Radius[$i]*2 >= $height Then
$Kugel_Vector[$i][1] = -$Kugel_Vector[$i][1]
If $Kugel_Position[$i][1] <= 0 Then
$Kugel_Position[$i][1] = 0
Else
$Kugel_Position[$i][1] = $height - 2*$Kugel_Radius[$i]
EndIf
EndIf
For $j = 0 To UBound($Strich)-1 Step 1

_GDIPlus_GraphicsFillRect($Buffer,$Kugel_Position[$i][0]+$Kugel_Radius[$i],$Kugel_Position[$i][1]+$Kugel_Radius[$i],4,4)

Local $sp = _Punkt_Linie($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $Strich[$j][0],$Strich[$j][1],$Strich[$j][2],$Strich[$j][3]) ; Der Punkt auf der Linie der

[/autoit] [autoit][/autoit] [autoit]

If _Punkt_in_RechtEck($sp[0], $sp[1], $Strich[$j][0],$Strich[$j][1],$Strich[$j][2],$Strich[$j][3]) Then ; Wenn die Spieler überhaupt mit der Seite kollidieren kann

[/autoit] [autoit][/autoit] [autoit]

If _Punkte_Distance($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $sp[0],$sp[1]) < $Kugel_Radius[$i] Then ; Prüpf ob die Positition überhaupt kollidieren kann.

[/autoit] [autoit][/autoit] [autoit]

Local $Spiegel = _Punkte_Winkel($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i],$sp[0],$sp[1]) + 90; Errechnet den Abprall-Winkel der Seites

Local $eintrittswinkel = _Punkte_Winkel(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1]) + 90

[/autoit] [autoit][/autoit] [autoit]

Local $neuer_winkel = _Spiegelwinkel($eintrittswinkel,$Spiegel) + 180

$Kugel_Position[$i][0] = $sp[0] - $Kugel_Radius[$i] + Sin(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der X-Position
$Kugel_Position[$i][1] = $sp[1] - $Kugel_Radius[$i] + Cos(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der Y-Position

_GDIPlus_GraphicsFillRect($Buffer,$sp[0],$Sp[1],4,4)
_GDIPlus_GraphicsDrawLine($Buffer,$sp[0],$Sp[1],$Kugel_Position[$i][0]+$Kugel_Radius[$i],$Kugel_Position[$i][1]+$Kugel_Radius[$i])

$Kugel_Vector[$i][0] = Sin($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1]) + $mov[0]
$Kugel_Vector[$i][1] = Cos($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1]) + $mov[1]

[/autoit] [autoit][/autoit] [autoit]

EndIf
EndIf

Local $Distanz = _Punkte_Distance($Kugel_Position[$i][0]+$Kugel_Radius[$i],$Kugel_Position[$i][1]+$Kugel_Radius[$i],$Strich[$j][0],$Strich[$j][1])

If $Distanz < $Kugel_Radius[$i] Then

Local $Speed = _Punkte_Distance(0,0,$Kugel_Vector[$i][0],$Kugel_Vector[$i][1])

[/autoit] [autoit][/autoit] [autoit]

$Kugel_Vector[$i][0] = (($Kugel_Position[$i][0]+$Kugel_Radius[$i]) - $Strich[$j][0]) / $Distanz * $Speed + $mov[0]
$Kugel_Vector[$i][1] = (($Kugel_Position[$i][1]+$Kugel_Radius[$i]) - $Strich[$j][1]) / $Distanz * $Speed + $mov[1]

EndIf
Next

For $j = 0 To UBound($Quadrat)-1 Step 1

#Region Ecken Kollision
For $Ecke = 0 To 7 Step 2
Local $Distanz = _Punkte_Distance($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i],$Quadrat[$j][$Ecke],$Quadrat[$j][$Ecke+1])
If $Distanz < $Kugel_Radius[$i] Then

Local $Speed = _Punkte_Distance(0,0,$Kugel_Vector[$i][0],$Kugel_Vector[$i][1])
$Kugel_Vector[$i][0] = (($Kugel_Position[$i][0]+$Kugel_Radius[$i]) - $Quadrat[$j][$Ecke]) / $Distanz * $Speed + $mov[0]
$Kugel_Vector[$i][1] = (($Kugel_Position[$i][1]+$Kugel_Radius[$i]) - $Quadrat[$j][$Ecke+1]) / $Distanz * $Speed + $mov[1]

Local $Winkel_Alt = _Punkte_Winkel(0,0,$Kugel_Vector[$i][0],$Kugel_Vector[$i][1]) + 90

;MsgBox(0,"",$Kugel_Vector[$i][0] & @LF & $Kugel_Vector[$i][1] & @LF & $Speed)

$Kugel_Position[$i][0] = $Quadrat[$j][$Ecke] + Sin(($Winkel_Alt)*$pi_div_180)*$Kugel_Radius[$i] - $Kugel_Radius[$i]
$Kugel_Position[$i][1] = $Quadrat[$j][$Ecke+1] + Cos(($Winkel_Alt)*$pi_div_180)*$Kugel_Radius[$i] - $Kugel_Radius[$i]

EndIf
Next
#EndRegion
#Region Seiten Kollision
For $punkt = 0 To 5 Step 2
Local $sp = _Punkt_Linie($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $Quadrat[$j][$punkt],$Quadrat[$j][$punkt+1],$Quadrat[$j][$punkt+2],$Quadrat[$j][$punkt+3])
If _Punkt_in_RechtEck($sp[0], $sp[1], $Quadrat[$j][$punkt],$Quadrat[$j][$punkt+1],$Quadrat[$j][$punkt+2],$Quadrat[$j][$punkt+3]) Then
If _Punkte_Distance($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $sp[0],$sp[1]) < $Kugel_Radius[$i] Then

Local $Spiegel = _Punkte_Winkel($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i],$sp[0],$sp[1]) + 90; Errechnet den Abprall-Winkel der Seites

Local $eintrittswinkel = _Punkte_Winkel(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1]) + 90

$Kugel_Position[$i][0] = $sp[0] - $Kugel_Radius[$i] + Sin(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der X-Position
$Kugel_Position[$i][1] = $sp[1] - $Kugel_Radius[$i] + Cos(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der Y-Position

_GDIPlus_GraphicsFillRect($Buffer,$sp[0],$Sp[1],4,4)
_GDIPlus_GraphicsDrawLine($Buffer,$sp[0],$Sp[1],$Kugel_Position[$i][0]+$Kugel_Radius[$i],$Kugel_Position[$i][1]+$Kugel_Radius[$i])

If $Spiegel + 90 < $eintrittswinkel And $Spiegel - 90 > $eintrittswinkel Then

Local $neuer_winkel = _Spiegelwinkel($eintrittswinkel,$Spiegel) + 180

$Kugel_Vector[$i][0] = Sin($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1])
$Kugel_Vector[$i][1] = Cos($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1])

[/autoit] [autoit][/autoit] [autoit]

EndIf

[/autoit] [autoit][/autoit] [autoit]

EndIf
EndIf
Next
Local $sp = _Punkt_Linie($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $Quadrat[$j][6],$Quadrat[$j][7],$Quadrat[$j][0],$Quadrat[$j][1])
If _Punkt_in_RechtEck($sp[0], $sp[1], $Quadrat[$j][6],$Quadrat[$j][7],$Quadrat[$j][0],$Quadrat[$j][1]) Then
If _Punkte_Distance($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i], $sp[0],$sp[1]) < $Kugel_Radius[$i] Then

Local $Spiegel = _Punkte_Winkel($Kugel_Position[$i][0]+$Kugel_Radius[$i], $Kugel_Position[$i][1]+$Kugel_Radius[$i],$sp[0],$sp[1]) + 90; Errechnet den Abprall-Winkel der Seites

Local $eintrittswinkel = _Punkte_Winkel(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1]) + 90

[/autoit] [autoit][/autoit] [autoit]

Local $neuer_winkel = _Spiegelwinkel($eintrittswinkel,$Spiegel) + 180

$Kugel_Position[$i][0] = $sp[0] - $Kugel_Radius[$i] + Sin(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der X-Position
$Kugel_Position[$i][1] = $sp[1] - $Kugel_Radius[$i] + Cos(($Spiegel+180) * $pi_div_180) * $Kugel_Radius[$i] ; Korrektur der Y-Position

_GDIPlus_GraphicsFillRect($Buffer,$sp[0],$Sp[1],4,4)
_GDIPlus_GraphicsDrawLine($Buffer,$sp[0],$Sp[1],$Kugel_Position[$i][0]+$Kugel_Radius[$i],$Kugel_Position[$i][1]+$Kugel_Radius[$i])

$Kugel_Vector[$i][0] = Sin($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1])
$Kugel_Vector[$i][1] = Cos($neuer_winkel*$pi_div_180) * _Punkte_Distance(0, 0, $Kugel_Vector[$i][0], $Kugel_Vector[$i][1])

[/autoit] [autoit][/autoit] [autoit]

EndIf
EndIf
#EndRegion
Next

Next

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Viereck_drehen($winkel)

Local $mittel_p_x = ($Strich[1][0] + $Strich[3][0]) / 2
Local $mittel_p_y = ($Strich[1][1] + $Strich[3][1]) / 2

Local $c = _Punkte_Distance($Strich[1][0], $Strich[1][1],$mittel_p_x,$mittel_p_y)

[/autoit] [autoit][/autoit] [autoit]

Local $dir = _Punkte_Winkel($mittel_p_x, $mittel_p_y, $Strich[1][0], $Strich[1][1]) + 90
$Strich[1][0] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[4][2] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[1][1] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$Strich[4][3] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$dir = _Punkte_Winkel($mittel_p_x, $mittel_p_y, $Strich[2][0], $Strich[2][1]) + 90
$Strich[2][0] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[1][2] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[2][1] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$Strich[1][3] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$dir = _Punkte_Winkel($mittel_p_x, $mittel_p_y, $Strich[3][0], $Strich[3][1]) + 90
$Strich[3][0] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[2][2] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[3][1] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$Strich[2][3] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$dir = _Punkte_Winkel($mittel_p_x, $mittel_p_y, $Strich[4][0], $Strich[4][1]) + 90
$Strich[4][0] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[3][2] = $mittel_p_x + Sin (($dir + $winkel)*$pi_div_180)*$c
$Strich[4][1] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c
$Strich[3][3] = $mittel_p_y + Cos (($dir + $winkel)*$pi_div_180)*$c

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Zeichnen ()

; _GDIPlus_GraphicsClear($Buffer,0xFFFFFFFF)

For $i = 0 To UBound($Kugel_Position) - 1 Step 1
_GDIPlus_GraphicsDrawPie ($Buffer, $Kugel_Position[$i][0], $Kugel_Position[$i][1], $Kugel_Radius[$i]*2, $Kugel_Radius[$i]*2,-_Punkte_Winkel(0,0,$Kugel_Vector[$i][0],$Kugel_Vector[$i][1]),360,$hPen)
Next
For $i = 0 To UBound($Quadrat)-1 Step 1
_GDIPlus_GraphicsDrawLine($Buffer, $Quadrat[$i][0], $Quadrat[$i][1], $Quadrat[$i][2], $Quadrat[$i][3], $hPen)
_GDIPlus_GraphicsDrawLine($Buffer, $Quadrat[$i][2], $Quadrat[$i][3], $Quadrat[$i][4], $Quadrat[$i][5], $hPen)
_GDIPlus_GraphicsDrawLine($Buffer, $Quadrat[$i][4], $Quadrat[$i][5], $Quadrat[$i][6], $Quadrat[$i][7], $hPen)
_GDIPlus_GraphicsDrawLine($Buffer, $Quadrat[$i][6], $Quadrat[$i][7], $Quadrat[$i][0], $Quadrat[$i][1], $hPen)
Next
For $i = 0 To UBound($Strich)-1 Step 1
_GDIPlus_GraphicsDrawLine($Buffer, $Strich[$i][0], $Strich[$i][1], $Strich[$i][2], $Strich[$i][3], $hPen)
Next

[/autoit] [autoit][/autoit] [autoit]

_GDIPlus_GraphicsDrawImageRect($hGraphic, $Bitmap,0,0, $width, $height)

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _beenden ()

[/autoit] [autoit][/autoit] [autoit]

_GDIPlus_GraphicsDispose ($hGraphic)
_GDIPlus_BitmapDispose($Bitmap)
_GDIPlus_GraphicsDispose($Buffer)
_GDIPlus_PenDispose ($hPen)

[/autoit] [autoit][/autoit] [autoit]

_GDIPlus_Shutdown ()

[/autoit] [autoit][/autoit] [autoit]

Exit

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit]

Und hier noch meine Mathe UDF:

Spoiler anzeigen

[autoit]

; Moritz Mathe UDf

[/autoit] [autoit][/autoit] [autoit]

Func _Punkte_Winkel($x1, $y1, $x2, $y2) ;Moritz Theorem

[/autoit] [autoit][/autoit] [autoit]

Local $winkel

[/autoit] [autoit][/autoit] [autoit]

$winkel = ACos(($x2 - $x1) / Sqrt(($x2 - $x1) * ($x2 - $x1) + ($y2 - $y1) * ($y2 - $y1))) * $180_div_pi

If $y2 > $y1 Then $winkel = -$winkel

Return $winkel

EndFunc ;==>Winkel zueinander

[/autoit] [autoit][/autoit] [autoit]

Func _Punkte_Distance($x1, $y1, $x2, $y2) ;Pythagoras Theorem

[/autoit] [autoit][/autoit] [autoit]

If $x2 = $x1 And $y2 = $y1 Then
Return 0
Else
Local $a, $b, $c
$a = $y2 - $y1
$b = $x2 - $x1
$c = Sqrt($a * $a + $b * $b)
Return $c
EndIf
EndFunc ;==>Punkt Distance

[/autoit] [autoit][/autoit] [autoit]

Func _Punkt_Linie($x,$y, $x1,$y1, $x2,$y2)

Local $m1, $m2, $p[2]

[/autoit] [autoit][/autoit] [autoit]

If $x1 = $x2 Then
$p[0] = $x1
$p[1] = $y
ElseIf $y1 = $y2 Then
$p[0] = $x
$p[1] = $y1
Else

$m1 = ($y2 - $y1) / ($x2 - $x1)
$m2 = -1 / $m1

$p[0] = (-$m1*$x1 + $y1 - $y + $m2 * $x) / ($m2 -$m1)
$p[1] = $m1 * ($p[0] - $x1) + $y1

[/autoit] [autoit][/autoit] [autoit]

EndIf

[/autoit] [autoit][/autoit] [autoit]

Return $p

[/autoit] [autoit][/autoit] [autoit]

EndFunc ;==>Punkt zu Linie

[/autoit] [autoit][/autoit] [autoit]

Func _Linien_Schnittpunkt($x1,$y1,$x2,$y2, $x3,$y3,$x4,$y4)

[/autoit] [autoit][/autoit] [autoit]

Local $m1 = ($y2 - $y1) / ($x2 - $x1)
Local $m2 = ($y4 - $y3) / ($x4 - $x3)

[/autoit] [autoit][/autoit] [autoit]

If $m1 = $m2 Then Return 0; Es gibt keinen Schnittpunkt

If $x1 = $x2 Then
Local $punkt[2]

$punkt[0] = $x1
$punkt[1] = $m2 * ($punkt[0] - $x3) + $y3

; MsgBox(0,"",$punkt[0] & " - " & $punkt[1])

Return $punkt
EndIf
If $x3 = $x4 Then
Local $punkt[2]
; MsgBox(0,"","")
$punkt[0] = $x3
$punkt[1] = $m1 * ($punkt[0] - $x1) + $y1

Return $punkt
EndIf
If $y1 = $y2 Then
Local $punkt[2]
$punkt[1] = $y1
$punkt[0] = ($punkt[1] + $m2*$x3 - $y3) / $m2
Return $punkt
EndIf
If $y3 = $y4 Then
Local $punkt[2]
$punkt[1] = $y3
$punkt[0] = ($punkt[1] + $m1*$x1 - $y1) / $m1
Return $punkt
EndIf
;ToolTip($m1 & " | " & $m2)
;Sleep(1000)

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Local $punkt[2]
$punkt[0] = ($m1*$x1 + $y3 - $y1 - $m2*$x3) / ($m1 - $m2)
; $punkt[0] = ($y3 + $m1*$y1 - $y1 - $m2*$x3) / ($m1 - $m2)
; $punkt[0] = (-$m1*$y1 - $y3 + $y1 + $m2*$x3) / ($m2 - $m1)
$punkt[1] = $m1 * ($punkt[0] - $x1) + $y1

Return $punkt

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _punkte_zu_vektor($x1,$y1, $x2,$y2)

Local $Vektor[2], $dist = _Punkte_Distance($x1, $y1, $x2, $y2)

$Vektor[0] = ($x1-$x2) / $dist
$Vektor[1] = ($y1-$y2) / $dist

Return $Vektor

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _Punkt_in_RechtEck($x,$y, $x1,$y1, $x2,$y2)

If _zwischen($x, $x1,$x2) And _zwischen($y, $y1,$y2) Then
Return True
Else
Return False
EndIf

EndFunc ;==>Prüft ob ein Punkt in einem Rechteck ist

[/autoit] [autoit][/autoit] [autoit]

Func _Highest($var1,$var2)

[/autoit] [autoit][/autoit] [autoit]

If $var1 > $var2 Then
Return $var1
Else
Return $var2
EndIf

EndFunc ;==>Gibt die höhere Variable zurück

[/autoit] [autoit][/autoit] [autoit]

Func _Lowest($var1,$var2)

If $var1 < $var2 Then
Return $var1
Else
Return $var2
EndIf

EndFunc ;==>Gibt die kleinere Variable zurück

[/autoit] [autoit][/autoit] [autoit]

Func _zwischen($var,$var1,$var2)

If $var >= _Lowest($var1,$var2) And $var <= _Highest($var1,$var2) Then
Return True
Else
Return False
EndIf

EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _Limit($var,$min,$max)
If $var < $min Then
Return $min
ElseIf $var > $max Then
Return $max
Else
Return $var
EndIf
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _Spiegelwinkel($eintrittswinkel,$Spiegel)

[/autoit] [autoit][/autoit] [autoit]

Return Mod($spiegel + ($spiegel - $eintrittswinkel + 360),360)

EndFunc ;==>Gibt die Spiegelung eines Winkel zurück

[/autoit]

Es wäre echt schön, wenn sich jemand bereit erklärt mir zu helfen

**UEZ**

Sieht jetzt schon sehr gut aus! Toll!

Zeitlich werde ich leider nicht machen können würde aber gerne! Müsste nur noch mein Mathe/Physik auffrischen...

Gruß,
UEZ

moritz1243

Das ist natürlich schade, weil ich hatte gehofft bei dem Projekt hilfe von jemandem zu bekommen der besser in mathe / physik ist als ich :(. Hier guck mal hier so sollte das dann am ende aussehen http://www.youtube.com/watch?v=LnvtZn2agmA. Kann du mir den dabei helfen die kraftübertragung zwischen den Vierecken hinzubekommen???

Faweyr

Naja, ich weiß ja nicht, ist das aber in Autoit schon möglich?
Jedoch, tolle Idee

JuraX

ich wüede für sowas eher java empfehlen

könnte dir aba ewentuell helfen

**UEZ**

Zitat von Faweyr

Naja, ich weiß ja nicht, ist das aber in Autoit schon möglich?
Jedoch, tolle Idee

Warum soll das nicht möglich sein? Die Grafiken darstellen ist nicht das Problem, sondern die Mathematik / Physik, die dahinter steckt!

Es ist absolut nicht trivial die Kollision und die daraus resultierende Bewegungen zu berechnen!

Die einfachsten Objekte sind Kugeln, alles andere wird komplizierter!

Gruß,
UEZ

Ubuntu

Es gibt zwar dafür bereits diverse Programme aber wenns dir Spass macht

mfg Ubuntu

moritz1243

Ich glaube langsam auch das es besser wäre mehr richtung c++ zu machen, da autoit echt langsam ist. Kennt jemand einen guten c++ editor weil codeblock ist nicht das gelbe vom ei.

Faweyr

Bloodshed Dev-C++, der is guaaat...find ich. Man kann damit auch C,C++,dlls... schreiben

tince

Hol dir am besten Visual Studio Express und das DirectX SDK.

In VC++ wurde auch AutoIt programmiert. 7-Zip auch und viele andere gute Programme.
Die OGRE Engine kannst du auch ohne Probleme in VC++ benutzen. Dafür gibt es das SDK.

@Faweyr: Hab damit mal gearbeitet, Codeblocks ist da viel besser.
Die Entwicklung ist auch ziemlich lahm.

moritz1243

visual studio habe ich mir schon herruntergeladen aber noch nicht eingearbeitet, ich denke aber das wird es sein.

Marthog

Ich hab Dev-C++ und VC++ 2008 Express-Edition installiert (beide kostenlos)

Dev-C++ ist ein guter Compiler für Anfänger, da man keine riesigen Projekte anlegen muss, aber für ganz große Projekte ist er dann etwas langsam.
Für VC++ muss man immer ein Projekt mit Debug-info und mehreren Dateien anlegen.

Wenn du nur sowas, wie im Video machen willst, kannst du einfach normal DirectX verwenden ohne sonstige Hilfen.
Allerding solltest du vorher die Grundlagen von C++ und Grundlagen der Win-Api-Guis lernen.

moritz1243

Ich beherrsche die grundlagen von c++ ich bin sogar schon etwas weiter würde ich sagen nur winapi müsste ich mir mal genauer anschauen habe es bis jetzt nur benutzt um tastatur oder sowas abzufragen.

So vielen dank für eure hilfe ihr habt mir sehr geholfen

Nilo

ich grabe diesen thread mal aus ich muss eins sagen würdest du die funktionen und das wissen aller deiner projekte zusammentun könntest du ein sehr gutes 3d spiel programmieren meine spontane idee ist dabei sowas wie Worms 3D

moritz1243

Hiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjaaaaaaaaaaaaaaaa, das wäre mega schwer und autoit ist für 3D zulangsam, außerdem bin ich gar nicht schlau genug dafür- sry aber das ist echt unmöglich. Ich habe schonmal versucht eine 3D engine mit autoit zu schreiben die konnte einen würfel anzeigen, aber viel mehr ist echt nicht möglich. Worm 2D wäre höchtes möglich.
Ich hatte auch vor mein Autoball script upzudaten, mal schauen.

grüße Moritz

**UEZ**

Zitat von moritz1243

Hiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjaaaaaaaaaaaaaaaa, das wäre mega schwer und autoit ist für 3D zulangsam, außerdem bin ich gar nicht schlau genug dafür- sry aber das ist echt unmöglich. Ich habe schonmal versucht eine 3D engine mit autoit zu schreiben die konnte einen würfel anzeigen, aber viel mehr ist echt nicht möglich. Worm 2D wäre höchtes möglich.
Ich hatte auch vor mein Autoball script upzudaten, mal schauen.

grüße Moritz

Schlau genug bist du, aber AutoIt mit GDI+ wäre da viel zu langsam

UEZ

moritz1243

Ja aber das ist trotzdem, auch wenn autoit schnell genug wäre ziehmlich schwer. Mal schauen, wenn man die irrlich engine richtig benutzen könnte oder mit opengl texturen richtig laden könnte, dann könnte man nochmal drüber reden