Beiträge von Andy

Zum Arkanoid:
Sehr gut gemacht, eigene Maps supereinfach zu erstellen, klasse Sound, ausreichende Grafik, was will man mehr

Genau SO muss das aussehen und sich spielen lassen! Dazu noch simpel programmiert, wirklich gute Arbeit!

Man kann das natürlich wesentlich vereinfachen, indem man Rechtecke verwendet und für die Kollisionsabfrage auch das oben schon besprochene "Raytracing".
Allerdings ist das nicht ganz so einfach wie von Mars vermutet. Bei großen Kugeln und kleinen Rechtecken muß man mehrere Strahlen verwenden um den genauen Kollisionspunkt zu finden. Es reicht ja nicht, DASS eine Kollision stattfindet, sondern man muss auch wissen WO! Das wird vor allem dann interessant, wenn sich mehrere Objekte bewegen. Intersection von Rechtecken (der Weg der Kugel beschreibt ja ein Rechteck und der "erste zu treffende" Brick) ist da sicherlich ein Ansatz.

Mir ging es jedenfalls darum, die "Logik" umzusetzen, so wenige wie möglich Kollisionsabfragen einzubauen. Man wartet so lange, bis Objekte sich in der unmittelbaren Nähe befinden und lässt erst dann eine Kollisionsabfrage laufen.

Hi,
hat mir natürlich keine Ruhe gelassen

#include <GDIPlus.au3>
#include <GDIPlus.au3>
_GDIPlus_Startup()




$width = 700
$height = 500


Global $A[5][100][100]                         ;flags für alle seitenteile
Global $W[5]                                   ;oben unten rechts links


Global $debug = 0                              ;0 für volle Geschwindigkeit
Global $debugsleep = 500                       ;sleep für die debugmeldungen


Opt("GUIOnEventMode", 1)




$hGUI = GUICreate("Bricks", $width, $height, 10, 10)
GUISetOnEvent(-3, "_EXIT")






GUISetState(@SW_SHOW)
$hGr = _GDIPlus_GraphicsCreateFromHWND($hGUI)
_GDIPlus_GraphicsClear($hGr, 0xFFFFFFFF)


$hBrush_rot = _GDIPlus_PenCreate(0xFFFF0000, 3) ;rot
$hBrush_gruen = _GDIPlus_PenCreate(0xFF00FF00, 3) ;grün
$hBrush_gelb = _GDIPlus_PenCreate(0xFF00FFFF, 3) ;gelb
Global $killpen = _GDIPlus_PenCreate(0xFFFFFFFF, 3) ;hintergrund
$pengruen = _GDIPlus_PenCreate(0xFF00FF00)


$misses = 0                                    ;überflüssige Berechnungen ob Brick getroffen


;Bricks erstellen
$Breite = 50
$Hoehe = 25


;Seitenteile
$O = 1                                         ;oben
$U = 2                                         ;unten
$R = 3                                         ;rechts
$L = 4                                         ;links






$AnzahlBricks = 0


;Seitenteile definieren und spielfeld zeichnen
For $x = 2 To ($width - $Breite * 2) / $Breite
    For $y = 2 To ($height - 200) / $Hoehe
        $col = 0xFF0F0000 + 2550 * $x + 20 * $y ;farbe
        $hBrush = _GDIPlus_PenCreate($col, 3)
        $A[$O][$x][$y] = 1
        _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe, $x * $Breite + $Breite - 5, $y * $Hoehe, $hBrush)
        $A[$U][$x][$y] = 1
        _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe + $Hoehe - 5, $x * $Breite + $Breite - 5, $y * $Hoehe + $Hoehe - 5, $hBrush)
        $A[$L][$x][$y] = 1
        _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe, $x * $Breite, $y * $Hoehe + $Hoehe - 5, $hBrush)
        $A[$R][$x][$y] = 1
        _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite + $Breite - 5, $y * $Hoehe, $x * $Breite + $Breite - 5, $y * $Hoehe + $Hoehe - 5, $hBrush)
        $AnzahlBricks += 1
    Next
Next


$t = 0


;Kreismittelpunkt und Radius
$Cx = 180
$Cy = 360
$Radius = 12


;startwinkel flugbahn
Global $fx = 1.7
Global $fy = -1.7
Global $fps
;Ball startet nach oben rechts, alle rechten und oberen Seitenteile ausblenden
Seitenteile_ausblenden($fx, $fy)


AdlibRegister("CalcFPS", 1000)




While 1                                        ;


    _GDIPlus_GraphicsDrawEllipse($hGr, $Cx - $Radius, $Cy - $Radius, 2 * $Radius, 2 * $Radius) ;Kreis zeichnen
    If $debug Then Sleep(20)
    sleep(1)


    ;Seitenteil getroffen?
    For $x = 2 To ($width - $Breite * 2) / $Breite
        If $x > ($Cx - 5 * $Radius) / $Breite And $x < ($Cx + 5 * $Radius) / $Breite Then ;nur die Seitenteile im Abstand vom doppelten Radius abfragen
            For $y = 2 To ($height - 200) / $Hoehe
                If $y > ($Cy - 5 * $Radius) / $Hoehe And $y < ($Cy + 5 * $Radius) / $Hoehe Then ;nur die Seitenteile im Abstand vom doppelten Radius abfragen


                    For $t = 1 To 4            ;alle Seitenteile,oben,unten,rechts,links
                        If $A[$t][$x][$y] = 1 Then ;nur wenn das Seitenteil existiert


                            If $debug Then _GDIPlus_GraphicsDrawEllipse($hGr, $Cx - 5 * $Radius, $Cy - 5 * $Radius, 10 * $Radius, 10 * $Radius, $pengruen)
;~ consolewrite($x&"   "&$y&@crlf)


                            If $W[$t] = 1 Then ; nur wenn seitenteil aktiv


                                $Ax = $x * $Breite
                                $Bx = $x * $Breite + $Breite - 5
                                Switch $t
                                    Case 1     ;oben
                                        $Ay = $y * $Hoehe
                                        $By = $y * $Hoehe
                                        If $debug Then ConsoleWrite("oben" & @CRLF)
                                    Case 2     ;unten
                                        $Ay = $y * $Hoehe + $Hoehe - 5
                                        $By = $y * $Hoehe + $Hoehe - 5
                                        If $debug Then ConsoleWrite("unten" & @CRLF)
                                    Case 3     ;rechts
                                        $Ax = $x * $Breite + $Breite - 5
                                        $Ay = $y * $Hoehe
                                        $Bx = $x * $Breite + $Breite - 5
                                        $By = $y * $Hoehe + $Hoehe - 5
                                        If $debug Then ConsoleWrite("rechts" & @CRLF)
                                    Case 4     ;links
                                        $Ay = $y * $Hoehe
                                        $Bx = $x * $Breite
                                        $By = $y * $Hoehe + $Hoehe - 5
                                        If $debug Then ConsoleWrite("links" & @CRLF)
                                EndSwitch


                                If $debug Then _GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_rot)


                                $timer1 = TimerInit()
                                Switch Beruehrung_Kreis_Strecke($Cx, $Cy, $Radius, $Ax, $Ay, $Bx, $By)
                                    Case 0     ;nichts berührt
                                        $misses += 1


                                    Case 1     ;strecke berührt


                                        If $debug Then
                                            WinSetTitle($hGUI, "", "BERÜHRUNG Strecke!!!!!!")
                                            _GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_gelb)
                                            Sleep($debugsleep)
                                        EndIf


                                        _deleteBrick($t, $x, $y)
                                        If $t = 1 Or $t = 2 Then $fy = -$fy ;oben oder unten getroffen, richtung umkehren
                                        If $t = 3 Or $t = 4 Then $fx = -$fx ;rechts oder links
                                        Seitenteile_ausblenden($fx, $fy)
                                        ExitLoop 3
                                    Case 2     ;ecke berührt


                                        If $debug Then
                                            WinSetTitle($hGUI, "", "BERÜHRUNG Ecke!!!!!!")
                                            _GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_gelb)
                                            Sleep($debugsleep)
                                        EndIf


                                        _deleteBrick($t, $x, $y)
                                        $fx = -Random(0.8, 1.2) * $fx
                                        $fy = -Random(0.8, 1.2) * $fy


                                        Seitenteile_ausblenden($fx, $fy)
;~                                         $fy = -$fy ;oben oder unten
;~                                         $fx = -$fx ;rechts oder links


                                        ExitLoop 3
                                EndSwitch
;~     Sleep(20)
;~                         ConsoleWrite(TimerDiff($timer1) & @CRLF)
                            EndIf
                        EndIf
                    Next
                EndIf
            Next
        EndIf
    Next




    ;in der Nähe der Wand?
    If $Cy < 1.2 * $Radius Or $Cy > $height - 1.2 * $Radius Then
        ;Wand oben oder unten getroffen?
        If Beruehrung_Kreis_Strecke($Cx, $Cy, $Radius, 0, 0, $width, 0) Or Beruehrung_Kreis_Strecke($Cx, $Cy, $Radius, 0, $height, $width, $height) Then
            $fy = -$fy
            Seitenteile_ausblenden($fx, $fy)
        EndIf
    EndIf
    If $Cx < 1.2 * $Radius Or $Cx > $width - 1.2 * $Radius Then
        ;Wand rechts oder links getroffen?
        If Beruehrung_Kreis_Strecke($Cx, $Cy, $Radius, $width, 0, $width, $height) Or Beruehrung_Kreis_Strecke($Cx, $Cy, $Radius, 0, 0, 0, $height) Then
            $fx = -$fx
            Seitenteile_ausblenden($fx, $fy)
        EndIf
    EndIf


    _GDIPlus_GraphicsDrawEllipse($hGr, $Cx - $Radius, $Cy - $Radius, 2 * $Radius, 2 * $Radius, $killpen) ;Kreis löschen
    $Cx = $Cx + $fx                            ;nächste koordinate Kreis
    $Cy = $Cy + $fy
    $fps += 1


WEnd




Func CalcFPS()
    WinSetTitle($hGUI, "", "Misses. " & $misses & "   FPS: " & $fps)
    $fps = 0
EndFunc                                        ;==>CalcFPS


Func _deleteBrick($t, $x, $y)                  ;alle 4 Seitenteile löschen
    $A[$O][$x][$y] = 0
    _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe, $x * $Breite + $Breite - 5, $y * $Hoehe, $killpen)
    $A[$U][$x][$y] = 0
    _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe + $Hoehe - 5, $x * $Breite + $Breite - 5, $y * $Hoehe + $Hoehe - 5, $killpen)
    $A[$R][$x][$y] = 0
    _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite, $y * $Hoehe, $x * $Breite, $y * $Hoehe + $Hoehe - 5, $killpen)
    $A[$L][$x][$y] = 0
    _GDIPlus_GraphicsDrawLine($hGr, $x * $Breite + $Breite - 5, $y * $Hoehe, $x * $Breite + $Breite - 5, $y * $Hoehe + $Hoehe - 5, $killpen)
    $AnzahlBricks -= 1
    If $AnzahlBricks = 0 Then Exit (MsgBox(0, "Bricks", "Spielfeld leer!"))
EndFunc                                        ;==>_deleteBrick
;==>


Func Beruehrung_Kreis_Strecke($Cx, $Cy, $R, $Ax, $Ay, $Bx, $By) ;Kreismittelpunkt und Radius, Streckenbegrenzung
    Local $AB2 = ($By - $Ay) ^ 2 + ($Bx - $Ax) ^ 2 ;AB²
    Local $AC2 = ($Cy - $Ay) ^ 2 + ($Cx - $Ax) ^ 2 ;AC²
    Local $BC2 = ($Cy - $By) ^ 2 + ($Cx - $Bx) ^ 2 ;BC²


    If Sqrt($AC2) <= $R Or Sqrt($BC2) <= $R Then Return 2 ;Berührung Endpunkt Gerade


    $Beruehrung_Abstand_von_A = ($BC2 - $AC2 - $AB2) / (-2 * Sqrt($AB2)) ;Abstand von A bis Berührpunkt
    If $Beruehrung_Abstand_von_A >= 0 And $Beruehrung_Abstand_von_A <= Sqrt($AB2) And Sqrt($AC2 - $Beruehrung_Abstand_von_A ^ 2) <= $R Then Return 1 ;Berührung Strecke


    Return 0


EndFunc                                        ;==>Beruehrung_Kreis_Strecke


Func atan2($y, $x)
    Return (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y))))
EndFunc                                        ;==>atan2






Func _EXIT()
    _GDIPlus_GraphicsDispose($hGr)
    _GDIPlus_Shutdown()
    Exit
EndFunc                                        ;==>_EXIT




Func Seitenteile_ausblenden($fx, $fy)          ;blendet alle Seitenteile aus, die nicht zu treffen sind
    If $fx >= 0 Then                           ;wenn ball nach rechts fliegt, dann keine rechten Seitenteile prüfen
        $W[$R] = 0
        $W[$L] = 1
    Else
        $W[$R] = 1
        $W[$L] = 0
    EndIf
    If $fy >= 0 Then                           ;wenn ball nach unten fliegt, dann keine unteren Seitenteile prüfen
        $W[$U] = 0
        $W[$O] = 1
    Else
        $W[$U] = 1
        $W[$O] = 0
    EndIf
EndFunc                                        ;==>Seitenteile_ausblenden

Schnell zusammengehackt, ohne den Sleep(1) in Zeile 87 habe ich knapp 500FPS...
Oben im Script kann man eine Variable $debug setzen, dann sieht man, wie ich versucht habe, die Kollisionsberechnungen zu minimieren.
Ich detektiere zwei Treffer, einmal auf die Fläche(Linie) eines der Seitenteile und dann die "Ecke". Bei einem Eckentreffer habe ich mir die Winkelberechnung geschenkt (es wird sowieso kein einziger Winkel berechnet!) und den Ball in eine zufällige Richtung zurückgeworfen.
Es werden nur Kollisionen berechnet, wenn AKTIVE Seitenteile in der Nähe sind. Aktiv heisst, das sind nur die, die aus der Richtung des Balls überhaupt getroffen werden können!
Diese werden im debug-Modus rot eingefärbt, die "Nähe" für die Kollisionsberechnung wird durch den grünen Kreis sichtbar gemacht.
Die im Fensterrahmen dargestellten "Misses" sind die Kollisionsberechnungen, welche keinen Treffer ergeben haben.

Hi,
"so ähnlich" habe ich mir das gedacht
Allerdings hast du mit AutoIt das Problem, dass du nicht viel Rechenzeit zur Verfügung hast. Daher auch der Hinweis auf die Seitenwände der Rechtcke.
Deine Funktion _BallHitBrick() funktioniert natürlich nur, weil dein Ball von unten kommt...
Fliegt der Ball von oben nach unten, wird die Kollision erst festgestellt, wenn die untere Seitenwand berührt wird

Löse dich von dem RECHTECK!
Wenn dein Ball nach rechts oben fliegt, kann NIEMALS ein linkes oder ein oberes Seitenteil getroffen werden, die Kollisions-Überprüfung reduziert sich auf die HÄLFTE!!!
Hast du dir mal Gedanken gemacht, wie du die 100 Rechtecke nacheinander auf Kollision prüfen willst?

Ich glaube, ich hack mal die 100 Zeilen zusammen um das Spiel zu programmieren^^

Zitat von xSunLighTx3

Ich hab das jetzt mal mit einem Rechteck versucht

Was habe ich denn oben geschrieben?

Zitat von Andy

Das Rechteck besteht aus 4 Eckpunkten ABUW, Teile in 4 Strecken auf: AB,BU,UW,WA

Wie soll denn eine Funktion, die Beruehrung_Kreis_Strecke() heißt, etwas anderes machen als den Berührungspunkt von einem Kreis und einer Strecke berechnen?
DU sollst aus dem Rechteck 4 Strecken(Seitenteile) machen, und die kannst du dann mit der Funktion überprüfen.

Zitat von xSunLighTx3

aber da bin ich schon mit der DrawLine überfordert,

Wenn du mit Trigonometrie, also simplen Sinus, Cosinus, Tangens auch so überfordert bist, solltest du dich dahingehend DRINGEND fit machen....
Wie siehts damit aus, den Kreis auf einem völlig leeren Spielfeld an den Wänden abprallen zu lassen, bekommst du das hin?

Zitat von xSunLighTx3

Das eigentliche Problem besteht darin, dass sich die Kugel ja nicht immer um +1 Koordinaten
bewegt.

Natürlich tut sie das...
Nur wirst du aus Geschwindigkeitsgründen die DARSTELLUNG DER KUGEL (genauer, des Kreises) immer um mehrere "Pixel" verschieben.
Da die Berührung des Kreises mit einem der Rechtecke immer nur (idealerweise) an einem Punkt/Pixel stattfindet, ist die Berechnung simpel:

- Der Kreis besteht aus dem Mittelpunkt C und dem Radius r
- Das Rechteck besteht aus 4 Eckpunkten ABUW, Teile in 4 Strecken auf: AB,BU,UW,WA

- Wenn der Abstand des Kreismittelpunktes zu einer der Strecken kleiner/gleich r, gibt es eine Berührung.
Beispiel für Abfrage, ob der Kreis die Strecke AB berührt, dazu benötigt man nur die Streckenlängen AB, AC und BC (diese Berechnung sollte wohl kein Problem darstellen^^)
Jetzt zur Auswertung:
Wenn AC<=r oder BC<=r dann Berührung!

BC² ist das Quadrat der Strecke BC usw, zuerst wird der Abstand des Kreismittelpunktes C senkrecht zur Strecke AB berechnet:
x = (BC²-AC²-AB²)/(-2*AB)
Auswertung:
Wenn x>=0 und x<=AB und sqrt(AC²-x²)<=r dann Berührung!

Script:

#include <GDIPlus.au3>
#include <GDIPlus.au3>
_GDIPlus_Startup()
$hGUI = GUICreate("", 500, 500)
GUISetState(@SW_SHOW)
$hGr = _GDIPlus_GraphicsCreateFromHWND($hGUI)
_GDIPlus_GraphicsClear($hGr, 0xFFFFFFFF)
$hBrush_rot = _GDIPlus_PenCreate(0xFFFF0000, 3)                  ;rot
$hBrush_gruen = _GDIPlus_PenCreate(0xFF00FF00, 3)                ;grün
$killpen = _GDIPlus_PenCreate(0xFFFFFFFF)                        ;hintergrund
;Strecke AB
$Ax = 200
$Ay = 150
$Bx = 350
$By = 260
_GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_rot)
;Kreismittelpunkt und Radius
$Cx = 180
$Cy = 240
$r = 40
For $x = 1 To 150
    _GDIPlus_GraphicsDrawEllipse($hGr, $Cx - $r, $Cy - $r, 2 * $r, 2 * $r) ;Kreis zeichnen
    If Beruehrung_Kreis_Strecke($Cx, $Cy, $r, $Ax, $Ay, $Bx, $By) Then
        WinSetTitle($hGUI, "", "BERÜHRUNG!!!!!!")
        _GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_rot)
        Sleep(80)
    Else
        WinSetTitle($hGUI, "", "")
        _GDIPlus_GraphicsDrawLine($hGr, $Ax, $Ay, $Bx, $By, $hBrush_gruen)
    EndIf
    Sleep(80)
    _GDIPlus_GraphicsDrawEllipse($hGr, $Cx - $r, $Cy - $r, 2 * $r, 2 * $r, $killpen) ;Kreis löschen
    $Cx = $Cx + 1                                               ;nächste koordinate Kreis
    $Cy = $Cy - 1
Next
_GDIPlus_GraphicsDispose($hGr)
_GDIPlus_Shutdown()
Func Beruehrung_Kreis_Strecke($Cx, $Cy, $r, $Ax, $Ay, $Bx, $By)  ;Kreismittelpunkt und Radius, Streckenbegrenzung
    Local $AB2 = ($By - $Ay) ^ 2 + ($Bx - $Ax) ^ 2               ;AB²
    Local $AC2 = ($Cy - $Ay) ^ 2 + ($Cx - $Ax) ^ 2               ;AC²
    Local $BC2 = ($Cy - $By) ^ 2 + ($Cx - $Bx) ^ 2               ;BC²
    If Sqrt($AC2) <= $r Or Sqrt($BC2) <= $r Then Return 2        ;Berührung Endpunkt Gerade
    Local $x = ($BC2 - $AC2 - $AB2) / (-2 * Sqrt($AB2))
    If $x >= 0 And $x <= Sqrt($AB2) And Sqrt($AC2 - $x ^ 2) <= $r Then Return 1 ;Berührung Strecke
    Return 0
EndFunc                                                          ;==>Beruehrung_Kreis_Strecke

//EDIT Beachte die Vereinfachung bei der Rückgabe der Funktion! 1 wenn die Strecke berührt wurde, 2 wenn einer der "Ecken"(Endpunkte) berührt wurden. das braucht man für die anschließende Berechnung der Winkel für den weiteren Flug...

Die Berechnung, ob die Linie den Kreis berührt, dauert auf meinem Rechner ca. 0.03ms .
Angenommen, das Spiel enthält 100 "Bricks", das ergibt 400 Linien/Seitenwände a 0.03ms ergibt 12ms für die Berechnung der Kollision ALLER 100 Bricks mit dem Kreis....

Wenn eine Kollision festgestellt wurde, ist der Rest doch nur noch den weiteren Winkel für die Flugrichtung anpassen. Das kann man sehr leicht machen, denn man weiß ja, ob eine obere, untere, rechte oder linke Seitenwand oder eine "Ecke" (Endpunkt der Strecke) getroffen wurde!

Alternativ könnte man "Raytraycing" machen, so wie es von Chip vorgeschlagen wurde. Dabei würde man parallele "Strahlen" von der Kreishälfte in Flugrichtung "aussenden" und schauen, wo diese ein (und welches) Objekt/Seitenteil treffen. Auf dem Weg des Kreises bis zum Kollisionspunkt hat man nichts weiteres zu tun als den Kreis darzustellen...
Es bietet sich an, nicht von jedem Punkt des Halbkreises ein "Ray" auszusenden, je nach Größe des Kreises und der Rechengeschwindigkeit reichen 10-12 Strahlen sicher aus.
Da nur der Kollisionspunkt "Ray" mit den Seitenwänden abgefragt werden muss (also nur der Schnittpunkt zweier Linien) ist die Berechnung schnell erledigt.
Wenn man dann noch clever selektiert ("rechte" Seitenwände können nur von einem nach links fliegenden Kreis getroffen werden, "untere" Seitenwände nur von einem nach oben fliegenden Kreis usw.), dann reduziert sich die Berechnung massiv! Dazu noch eine clevere Anordnung der Seitenteile im Array und auch AutoIt hat massig Zeit übrig um für ausreichende FPS zu sorgen

Hi,

Zitat von TheDude

woran kann es liegen, daß ControlSend den Inhalt eines String nur lower-case an ein Fenster sendet?

wer weiß, was er tut und das System verstanden hat, und dazu ggf. auch die Hilfe lesen kann, ist (wie so oft) besser dran
Gesendet werden TASTENDRÜCKE einer Tastatur, genau wie in der Hilfe beschrieben. Dort steht

Zitat von Zitat aus der Hilfe zu ControlSend()

ControlSend arbeitet ähnlich wie Send, aber es kann Tastendrücke direkt an ein beliebiges Fenster bzw. Control senden und nicht nur
an das gerade aktive Fenster.

Weiterhin der Hinweis (bzgl. Putty)

Zitat von Zitat aus der Hilfe zu ControlSend()

Nur bei Kommandozeilen-Fenstern (DOS-Boxen) arbeitet ControlSend unzuverlässig, weil diese anders funktionieren als normale Fenster (scheint physische Zustände zu überprüfen, anstatt den String entgegen zu nehmen).

"unzuverlässig" bedeutet, dass genau der vom TE beobachtete Vorgang ausgeführt wird, nämlich dass die "normalen" Tastenanschläge (wie auch so vorgesehen) gesendet werden!

Wenn man also Tastenanschläge simulieren will, tut man gut daran, das auch zu tun! Wenn man an ein Control "ABC" senden will, dann gehört dazu die Shift-Taste gedrückt!
Oder würdet ihr einen Thread erstellen mit dem Titel:"Wenn ich im Editor abc eingebe, dann wird dort abc angezeigt, ich will aber ABC haben!"

Die Scripte von Zeitriss in Post #5 beschreiben den Ersatz von + statt {SHIFT}, was funktionieren sollte. Bei {T} als Ersatz für ein großes T wäre ich mir nicht sicher, ich würde, allein aus Verständnisgründen für die Funktion des Scripts, {SHIFT}t vorziehen.

Zitat von smartpart82

Als Psychologe finde ich es höchst faszinierend

Wenn du als Psychologe genau so eine Pfeife bist, wie als Fragesteller, dann solltest du dir dringend ein neues Beschäftigungsfeld suchen, so wird das definitiv nix!
Und das ist jetzt ganz und gar nicht sarkastisch oder polemisch gemeint, sondern eher konsterniert...
Ein Psychologe, der nicht mal weiß, wie er Fragen zu stellen hat, DAS lässt den Glauben an diese Zunft in mir noch weiter sinken.

Zitat von smartpart82

Auch die Projektion ist interessant.

hmmm...hier wird nicht projeziert, hier wird größtenteils versucht, problemorientiert und professionell zu arbeiten. Projezieren kannst du gerne in deiner Freizeit bzw. bei der Arbeit, ich mache das aus Zeitnot weder auf der Arbeit, noch in meiner wenigen Freizeit! Du stellst eine Frage, du bekommst die dazu passende Antwort. Nicht mehr und nicht weniger.

Wenn du weiterhin in problemlösungsorientierten Foren nach Lösungen suchen solltest, lies dir den verlinkten Inhalt in meiner Signatur "wie man Fragen richtig stellt" durch. Das öffnet dir die Augen, wie die meisten hier "ticken"!

Zitat von smartpart82

Beim Programm handelt es sich um ein durch eine externes IT Unternehmen speziell für mein Unternehmen angefertigtes Datenspeicher- und Verarbeitungssystem

Als ich das gelesen hatte, musste ich lachen. Wirklich! Dieses IT-Unternehmen musst du ja ganz schön geärgert haben, dass sie dir nicht mal telefonisch mitteilen, in welcher UTF-Kodierung ihre Textdatei vorliegt!

Zitat von smartpart82

Wenn du/ihr nicht über entsprechende Kompetenz oder über entsprechendes Interesse verfügt

Ich habe dir im ersten Satz meines Postings einen Lösungsansatz gegeben! Wieso hast du diesen nicht umgesetzt?
FileOpen() mit diversen Parametern, da ich davon ausgehe, dass ein einfaches UTF8/UTF16-Dekodierungs-"Problem" vorliegt. Dies ist in der Hilfe zu FileReadToArray() entsprechend dokumentiert.
Woher ich wußte, dass du FileReadToArray() nicht mit dem FileOpen-Handle, sondern mit dem Dateinamen als Parameter verwendest ohne das Script gesehen zu haben? DAS hat mit Kompetenz zu tun...

Zitat von smartpart82

Ich denke dafür ist unser aller Zeit zu kostbar.

Sehe ich nicht so. Ich (und auch andere Forenmitglieder) habe(n) trotz deiner unprofessionellen Fragestellung eine hilfreiche Antwort mit einigen Lösungsmöglichkeiten gepostet. Auf KEINE davon bist du eingegangen! Das ist für mich ein Zeichen von Lernresistenz und Ignoranz gegenüber den Leistungen von Helfern!

Statt hier weiterzumachen, leg ich mich lieber auf die Couch.
Couch, Couch...da war doch was ...Psychologe.....nein, jetzt ist Schluss

Zitat von smartpart82

Jetzt wollte ich die Datei mit FileReadToArray auslesen.

Wieso öffnest du die Datei nicht "normal" mittels FileOpen (alle Parameter beachtet/probiert?!) statt über den Dateinamen?

Zitat von smartpart82

Vom Programmablauf soweit kein Problem.

Offensichtlich doch, s. oben....
Du bist ja nicht mal in der Lage, (d)ein (Minimal)Script zu zeigen, Angaben über das Programm welches das Logfile erstellt zu machen, oder auch nur die ersten 100 Bytes des *.dat-Files zu posten und erwartest ernsthaft, dass dir hier jemand hilft bzw. DEIN Problem löst?
Ich jedenfalls habe absolut keine Lust, dir Würmer aus der Nase zu ziehen und nachzufragen was du alles schon gemacht/nicht gemacht hast! Und eins ist sicher, 90% der Forenmitglieder mit Ahnung vom Thema haben dazu auch keine Lust!

Nur mal zum Verständnis, die "Lösung" deines Problems ist sehr einfach und wäre sicher in der ersten Antwort erledigt gewesen! Allerdings macht sich hier niemand die Mühe die Lösung zu posten wenn du dir nicht mal die Mühe machst, grundlegende Informationen bereitzustellen.
Also fang an, problemlösungsorientiert zu arbeiten, DU willst schließlich etwas von uns!

Heute habe ich in der aktuellen c´t einen umfassenden Bericht zum Thema von Apples neuer Grafikschnittstelle Metal gelesen. Diese ist, da Apple eins der führenden Mitglieder der Khronos-Group ist, sehr nah mit Vulkan verwandt. Verglichen wird im Bericht fast ausschliesslich mit OpenGL, Vor- und Nachteile werden herausgestellt.
Dabei interessant ist der Ansatz von Vulkan/Metal, dem Entwickler mehr Freiheiten (und vor allem auch Verantwortlichkeiten! ) im Bezug auf die Programmierung der Hardware zu geben, und somit die API extrem schlank und somit schnell zu machen!
Etwas, dass GDI/GDI+ gänzlich fehlt....

M$ geht davon aus, dass alle machbaren Fehler seitens Programmierer auch gemacht werden, und darauf hin werden die API´s programmiert! Fehlermanagement der allerfeinsten Sorte, die Funktionen werden laufzeittechnisch totgespielt, da man von einem Vollhonk von Anwender ausgeht (und das in vielen Fällen leider auch muss, wer das nicht glaubt, der liest die Beiträge zu diesem Thema in gängigen Foren... ). Oberste Priorität ist dabei, ALLE möglichen und unmöglichen Fehler des Anwenders abzufangen und diese dann in einer schönen Message auszugeben. Nicht umsonst ist die erste Frage auf die geschilderten Probleme des Anwenders/Programmierers (in AutoIt lautet diese Frage übrigens genauso unisono) "Wie lautet denn der Fehlercode/die Errormeldung?!"

Ich gehe davon aus, dass GDI(+) nur deshalb noch existiert, weil es die Grundlage der M$-Fensterdarstellung ist. Für grafische Fensterinhalte gibt es andere/bessere/schnellere Grafikbibliotheken.

Wieso GDI+ bei identischen Funktionen meßbar langsamer ist als das "uralte" GDI, sollte jetzt klar sein . Dazu der imho inkonsistente und unverständliche Gebrauch verschiedenster Funktionsverweise/namen wie bsp. Graphics/Bitmap/HBitmap/Image in GDI+ für ein und dasselbe schrecken mich immer von neuem ab.
Entweder "schnell" in oldschool GDI oder aber gleich eine wirklich schnelle Alternative wie D2D/OpenGL wobei OpenGL wie oben beschrieben für "professionelle" Anwendungen auch schon wieder als zu langsam/schwerfällig empfunden wird...

...und wieder mal wird auch bei "aufwendiger" Grafik klar, wieviel schneller die uralten GDI- gegenüber den "plus"-Funktionen sind
Bei AutoIt fällt der Unterschied garnicht auf, bei FB ist bei mir die GDI-Version ca. 5-6x schneller als GDI+

Abgesehen davon habe ich mir natürlich den erzeugten ASM-Code angeschaut
Der "klassisch" aufgebaute Compiler nutzt exzessiv (6KB) den Stack zum Zwischenschenspeichern der Variablen, JEDER der FPU-Befehle (SSE hat deshalb auch keinerlei Vorteile) greift statt auf innerhalb der FPU speicherbaren Werte/Konstanten auf das RAM zu....
Ich bin ziemlich sicher, dass mindestens noch ein Faktor 5-10 in der Geschwindigkeit der Berechnung machbar wäre, würde man die FPU-Sequenz in Assembler handcoden....von SSE mit 4 gleichzeitig berechenbaren Arrayinhalten garnicht zu reden. Die Compilereinstellung zur Verwendung von SSE bringt übrigens keinen Vorteil, die "schnelleren" Befehle werden gänzlich von unproduktiven Zugriffen auf den Speicher ausgebremst

Beispielsweise kann

ringf(r)     = posx + Cos(t) * multiplier
			ringf(r + 1) = posy + Sin(t) * multiplier
			ringf(r + 2) = posx + Cos(t + tstep) * multiplier
			ringf(r + 3) = posy + Sin(t + tstep) * multiplier

per SSE in einem Rutsch berechnet werden!
Mal abgesehen davon, dass sämtliche Konstanten in den Registern statt im Speicher gehalten werden können und somit auch damit schneller gerechnet werden kann.

Gerade dieser Code ist ein Beispiel dafür, dass "Compiler" auch nicht zaubern können . "Klassisch" aufgestellte schon mal garnicht...
Ich würde sonstwas dafür geben, mal zu sehen, was einer den modernen (Intel) Compiler aus dem Quellcode macht...
Vielleicht hat ja jemand Lust, den Quellcode nach C(++) zu übertragen und zu testen?!

Große Performancesprünge erwarte ich damit übrigens nicht, die FPS werden definitiv durch GDI/GDI+ begrenzt und nicht durch die Handvoll Berechnungen

Zitat von diablisch

Wie bringe ich den server dazu, dass er das an den Client meldet?

Ich gehe davon aus, dass du dieses Script nicht geschrieben hast!
Ansonsten wüßtest du, was in den einzelnen Funktionen abläuft und wüßtest auch, was UDPsend()/TCPsend() machen!

Hi,
für die Benennung von Variablen und deren Verwendung gibt es die Befehle EVAL() und ASSIGN().
Wobei ich auch den Sinn des Verfahrens des TE in Frage stelle, ich würde ein Array mit allen in der Konfigurationsdatei vorhandenen Variablen und Werten aufziehen und damit arbeiten.

ich zitiere mich mal selbst...
Client sendet an Server nicht übers Inet

Hi,
Mach mal das Fenster aktiv (Klick auf den Rahmen) und drücke dann Ctrl+C für kopieren.
Mach einen Editor auf und Ctrl-V für einfügen.
Windows versucht selbstständig so viele Informationen über das Fenster zu bekommen, u.a. auch enthaltener Text, der dann per "einfügen" abgefangen werden kann.
So bekommt man auch Text aus MessageBoxen und aus vielen anderen Fenstern heraus...

Initialization Time: 48.1170888974373
Second Write Time: 0.0556868348262534

Initialization Time: 4.37654558443699
Second Write Time: 0.065944935978458

Zitat von water

Ich vermute Windows Initialisierungs Overhead

hmmm, wer weiß, wie das ablauftechnisch umgesetzt ist...knapp Faktor 100 ist schon eine Hausnummer!

Hi,

ja, du könntest die gesamte Tabelle als csv speichern,spaltenweise...

Bzgl. SQL, du kannst innerhalb von VBA so gut wie alle Dateiformate als "Datenbank" öffnen, also auch eine "normale" XLS-Datei. Bearbeiten/Abfragen kannst du diese dann wie jede andere Datenbank auch.

Ich habe mir da einmal eine Vorlage/Funktion geschrieben, sämtliche SQL-Abfragen lese ich als Textdatei ein. So muss ich nur noch die beispielsweise mit dem DB-Manager erstellten DB-Abfragen in eine Textdatei kopieren, fettich! Bin kein DB-Fuzzi, und um bspw. eine Abfrage zu ändern/erweitern editiere ich nur die Textdatei mit der Abfrage und muss nicht in tausenden Zeilen Code und zig Modulen rumsuchen.

Wie kommen denn deine Daten nach Excel bzw. woher kommen die Daten überhaupt und was ist das Ziel bzw. was muss/soll mit den gefundenen Daten gemacht werden?
Bei AutoIt müßtest du die komplette Anwendung schreiben, incl. in/out. Da stellt sich die Frage, ob sich das lohnt...

Hi,
ich habe auf diesem Rechner leider kein Excel, habe aber dein Script mit OpenOffice durchleuchtet.
Du hat das gleiche Problem wie fast sämtliche "Macro-Programmierer" auch. Du versuchst, zu "Exceln", statt zu programmieren...
Mit
arrSuch = .Range(.Cells(1, 1), .Cells(lngLetzte2, 1))
bist du auf dem richtigen Dampfer, du überträgst die Suchzellen in ein Array! Allerdings machst du mittels
If wksBlatt1.Cells(lngZeile + i - 1, lngSpalte) = arrSuch(i, 1) Then
wieder alles zunichte...du vergleichst "langsam" Zellinhalte mit (schnell) Arrayinhalten.
Jetzt kommt der Einwand "ja aber Excel kann doch keine Arrays größer xxxx anlegen!!!". DAS meinte ich mit "Exceln" statt programmieren! Niemand zwingt dich, ALLE Zeilen in ein Array zu packen, du könntest auch nacheinander mehrere Blöcke aus der Tabelle nacheinander in EIN Array schreiben und dieses dann sehr schnell mit VBA durchsuchen!

Anderer Weg:
Speichere jede Spalte als CSV, und suche dann in dieser Datei mittels INSTR() nach den Suchbegriffen. Die von INSTR() zurückgegebenen Positionen sind die "Zeilen" (bzw. die Anzahl der Kommas bis dorthin).
Ich vermute ganz stark, das ist die schnellste Methode!

Das hier ist ein Forum für Hilfe und Unterstützung!
Wenn du willst, dass dir hier komplette Scripte erstellt werden, bist du falsch!
Dafür gibt es den Bereich "Programmieranfragen", dort wird sich evtl. jemand finden, der dir Scripte schreibt, während du deiner Arbeit oder Freizeitbeschäftigung nachgehst. Dir sollte klar sein, dass diese Leistung entsprechend honoriert werden muß, richte dich je nach Komplexität des Scripts auf entsprechende Zahlungen ein.

Allerdings bist du nicht einmal in der Lage, (D)ein Problem zu schildern und einen Lösungsversuch zu posten. Zeig ein Script und beschreibe, was du hast und erörtere das Ziel, welches du erreichen willst.
Wenn du nicht weißt, wie man Fragen richtig stellt, klick in meiner Signatur auf den entsprechenden Link, nimm dir dafür Zeit und berücksichtige, was dort steht!

Ja