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
#include <GuiConstants.au3>
#include <GDIPlus.au3>
#include <Misc.au3>
#include <Mathe.au3>
#include <Array.au3>
HotKeySet("{ESC}", "_beenden")
[/autoit] [autoit][/autoit] [autoit]Opt('MustDeclareVars', 1)
Opt('GuiOnEventMode', 1)
Opt ('MouseCoordMode', 0 )
Global $hGUI, $hWnd, $hGraphic, $Bitmap, $Buffer, $hPen, $msg
Global $width = 640
Global $height = 400
Global $titel = "Titel"
Global $version = " v XXX"
Global Const $pi = 3.14159265358979
Global Const $pi_div_180 = $pi/180
Global Const $180_div_pi = 180/$pi
Global $Kugel_Masse
Global $Kugel_Radius
Global $Kugel_Position
Global $Kugel_Vector
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
$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
EndFunc
#EndRegion
Kugel_Hinzufuegen(100, 100, 20, 10, 9)
Kugel_Hinzufuegen(200, 100, 20, -8, 10)
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
$hGUI = GUICreate($Titel & $version, $width, $height,-1,-1)
GUISetOnEvent($GUI_EVENT_CLOSE, "_beenden")
$hWnd = WinGetHandle($Titel & $version)
GUISetState(@SW_SHOW)
Global $Quadrat
#Region Quadrat hinzufügen
Func Rechteck_Hinzufuegen($x, $y, $breite, $hoehe)
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
EndFunc
#EndRegion
Rechteck_Hinzufuegen(100, 300, 100, 60)
GUISetCursor(16) ;unsichtbar
[/autoit] [autoit][/autoit] [autoit]Global $Aktuelle_Kugel = 0
Global $Richtung
Global $Geschwindigkeit
_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)
AdlibEnable("Main", 25)
[/autoit] [autoit][/autoit] [autoit]While 1
Sleep(3000)
WEnd
Func Main()
_GDIPlus_GraphicsClear($Buffer,0xFFFFFFFF)
Input()
Kugeln()
Zeichnen()
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
$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
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
For $i = 0 To 7 Step 2
$Quadrat[$ID][$i] += $x
$Quadrat[$ID][$i+1] += $y
Next
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
EndFunc
[/autoit] [autoit][/autoit] [autoit]Func Kugeln()
Kugeln_Bewegen()
Kugeln_Kollisionen()
EndFunc
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
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
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
;$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
$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
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
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]
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])
$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])
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
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])
EndIf
EndIf
#EndRegion
Next
Next
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)
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
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
_GDIPlus_GraphicsDrawImageRect($hGraphic, $Bitmap,0,0, $width, $height)
EndFunc
Func _beenden ()
[/autoit] [autoit][/autoit] [autoit]_GDIPlus_GraphicsDispose ($hGraphic)
_GDIPlus_BitmapDispose($Bitmap)
_GDIPlus_GraphicsDispose($Buffer)
_GDIPlus_PenDispose ($hPen)
_GDIPlus_Shutdown ()
[/autoit] [autoit][/autoit] [autoit]Exit
[/autoit] [autoit][/autoit] [autoit]EndFunc
[/autoit]Und hier noch meine Mathe UDF:
Spoiler anzeigen
; Moritz Mathe UDf
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
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
Func _Punkt_Linie($x,$y, $x1,$y1, $x2,$y2)
Local $m1, $m2, $p[2]
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
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)
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)
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
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
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
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
Func _Lowest($var1,$var2)
If $var1 < $var2 Then
Return $var1
Else
Return $var2
EndIf
EndFunc ;==>Gibt die kleinere Variable zurück
Func _zwischen($var,$var1,$var2)
If $var >= _Lowest($var1,$var2) And $var <= _Highest($var1,$var2) Then
Return True
Else
Return False
EndIf
EndFunc
Func _Limit($var,$min,$max)
If $var < $min Then
Return $min
ElseIf $var > $max Then
Return $max
Else
Return $var
EndIf
EndFunc
Func _Spiegelwinkel($eintrittswinkel,$Spiegel)
[/autoit] [autoit][/autoit] [autoit]Return Mod($spiegel + ($spiegel - $eintrittswinkel + 360),360)
EndFunc ;==>Gibt die Spiegelung eines Winkel zurück
Es wäre echt schön, wenn sich jemand bereit erklärt mir zu helfen