Beiträge von Yjuq

Hi, wir sind ein Programmierforum für die Programmiersprache AutoIt. Wir haben erst mal prinzipiell nichts mit Autos am Hut. Aber vielleicht bekommst du dennoch eine hilfreiche Antwort von jemanden. Lediglich als kleine Info für den Fall dass dir garkeiner antworten sollte.

LG. Yjuq

Naja, das ist auch ganz simpel. Im prinzip werden die neuen Events gefetcht nachdem du GuiGetMsg() aufrufst. Demnach musst du es nur aufrufen und auf Events reagieren:

#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>

Local $hMainGUI = GUICreate("Hallo Welt", 310, 100)
GUICtrlCreateLabel("Klicke auf OK und dann auf den Close- oder Cancel-Button." & @CRLF _
  & "Schleife wird NICHT beendet, GUI wird NICHT geschlossen!", 10, 10, -1, 50)
Local $iOKButton = GUICtrlCreateButton("OK", 80, 70, 60)
Local $iCancelBtn = GUICtrlCreateButton("Cancel", 160, 70, 60)
GUISetState(@SW_SHOW, $hMainGUI)

Global $g_bCancel = False
Global $bOK = False

While 1
  ConsoleWrite("$g_bCancel (MainLoop): " & $g_bCancel & @CRLF)
  If $bOK Then
    $bOK = False
    TestFunc1()
  EndIf

    events()
WEnd

Func TestFunc1()
  Local $iCnt = 0
  Do
    Sleep(250)
    ConsoleWrite("$g_bCancel: " & $g_bCancel & @CRLF)
    If $g_bCancel Then
      $g_bCancel = False
      ExitLoop
    EndIf

    GUICtrlSetData($iOKButton, $iCnt)
    $iCnt += 1
    events()
  Until $iCnt = 40 ; Läuft ca. 10 Sekunden.
EndFunc   ;==>TestFunc1

Func events()
      Switch GUIGetMsg()
    Case $GUI_EVENT_CLOSE
      Exit

    Case $iOKButton
      $bOK = True
      ConsoleWrite("$g_bCancel (Ende): " & $g_bCancel & @CRLF)

    Case $iCancelBtn
      $g_bCancel = True

  EndSwitch
EndFunc

Sleep() verhindert aber das sofortige schließen. Ist genauso ein Fall den du nicht in Events setzen möchtest. Hier mal eine Variation mit einen richtigen Timer:

#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>

Local $hMainGUI = GUICreate("Hallo Welt", 310, 100)
GUICtrlCreateLabel("Klicke auf OK und dann auf den Close- oder Cancel-Button." & @CRLF _
  & "Schleife wird NICHT beendet, GUI wird NICHT geschlossen!", 10, 10, -1, 50)
Local $iOKButton = GUICtrlCreateButton("OK", 80, 70, 60)
Local $iCancelBtn = GUICtrlCreateButton("Cancel", 160, 70, 60)
GUISetState(@SW_SHOW, $hMainGUI)

Global $g_bCancel = False
Global $bOK = False

While 1
  ConsoleWrite("$g_bCancel (MainLoop): " & $g_bCancel & @CRLF)
  If $bOK Then
    $bOK = False
    TestFunc1()
  EndIf

    events()
WEnd

Func TestFunc1()
    Local $iCnt = 0
    Local $timer = TimerInit()
  Do
    If TimerDiff($timer) > 250 Then
        ConsoleWrite("$g_bCancel: " & $g_bCancel & @CRLF)
        If $g_bCancel Then
        $g_bCancel = False
        ExitLoop
        EndIf

        GUICtrlSetData($iOKButton, $iCnt)
        $iCnt += 1
        $timer = TimerInit()
    EndIf
    events()
  Until $iCnt = 40 ; Läuft ca. 10 Sekunden.
EndFunc   ;==>TestFunc1

Func events()
      Switch GUIGetMsg()
    Case $GUI_EVENT_CLOSE
      Exit

    Case $iOKButton
      $bOK = True
      ConsoleWrite("$g_bCancel (Ende): " & $g_bCancel & @CRLF)

    Case $iCancelBtn
      $g_bCancel = True

  EndSwitch
EndFunc

Solche Sachen lassen sich aber mit einer "Manager" Funktion, welche AutoIt Skript von dem Windows Events trennt, ziemlich einfach lösen.

Du solltest in Windows Events prinzipiell keine Schleifen verwenden. Das sorgt nur dafür dass sich das Programm aufhängt und Events nicht mehr richtig funktionieren.

Stattdessen kannst du eine Variable in dem Event setzen um dann deine gewünschte Funktion aufzurufen:

#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>

Opt("GUIOnEventMode", 1) ; Wechsle in den OnEvent Modus

Local $hMainGUI = GUICreate("Hallo Welt", 300, 100)
GUISetOnEvent($GUI_EVENT_CLOSE, "CLOSEButton")
GUICtrlCreateLabel("Klicke auf OK und dann auf den Close-Button." & @CRLF _
  & "GUI wird NICHT geschlossen!", 30, 10, -1, 50)
Local $iOKButton = GUICtrlCreateButton("OK", 120, 70, 60)
GUICtrlSetOnEvent($iOKButton, "OKButton")
GUISetState(@SW_SHOW, $hMainGUI)

Global $g_bCancel = False
Global $bOK = False

While 1
  Sleep(100) ; Im Leerlauf bummeln
  ConsoleWrite("$g_bCancel (MainLoop): " & $g_bCancel & @CRLF)
  If $bOK Then
      TestFunc1()
      $bOK = False
  EndIf
WEnd

Func OKButton()
  ; Beachte: an diesem Punkt w&auml;re @GUI_CtrlId gleich $iOKButton,
  ; und @GUI_WinHandle w&auml;re gleich $hMainGUI
;   MsgBox($MB_OK, "GUI Event", "Du hast auf OK geklickt!")
    If $bOK = True Then $g_bCancel = True
  $bOK = True
EndFunc   ;==>OKButton

Func CLOSEButton()
  ; Beachte: an diesem Punkt w&auml;re @GUI_CtrlId gleich $GUI_EVENT_CLOSE,
  ; und @GUI_WinHandle w&auml;re gleich $hMainGUI
;   MsgBox($MB_OK, "GUI Event", "Du hast auf CLOSE geklickt! Programm wird beendet...")
  $g_bCancel = True
  Exit
EndFunc   ;==>CLOSEButton

Func TestFunc1()
  Local $iCnt = 0
  Do
    Sleep(250)
    ConsoleWrite("$g_bCancel: " & $g_bCancel & @CRLF)
    If $g_bCancel Then Exit

    GUICtrlSetData($iOKButton, $iCnt)
    $iCnt += 1
  Until $iCnt = 40 ; Läuft ca. 10 Sekunden.
EndFunc   ;==>TestFunc1

Noch schöner (und bei einer größeren GUI) ist natürlich eine Funktion die das managed.

Wenn du Probleme mit Deutsch hast: Ich bin auch der englischen Sprache mächtig, falls das für dich angenehmer ist. Du darfst mir auch gerne private Nachrichten über das Forum schreiben. Ich antworte sobald ich diese sehe. Bin aber eher einer der mehr inaktiven Mitglieder hier. Ich brauch AutoIt nicht mehr so häufig wie ich es mal gebraucht hatte.

Den Kommentar zu der "Spieleautomation" oder wie du es nanntest "Spielautomaten" bezieht sich auf Programme, welche darauf abziehlen Computerspiele zu automatisieren. Dies widerspricht den Forenregeln und wird hier nicht geduldet. Das hat nichts mit einem Casino zu tun.

Die Dokumentationen sind manchmal schwer zu verstehen wenn man den Sinn hinter einigen Sachen nicht kennt oder Vergleichsbeispiele hat. Weißt du was über Elektrotechnik und wie Logic-Gates funktionieren? Diese Bit-Funktionen machen genau das Selbe, lediglich mit mehreren "Signalen" gleichzeitig. Du kannst dich ja mal ein wenig hier durchwühlen: Logic Gates

Es gab da auch eine gute Deutsche Seite über Elektrotechnik. Aber mir fällt der Name nicht mehr ein... Sorry

Musashi - Ich denke eine vorgefertigte Lösung zu präsentieren hilft nicht wirklich. Ich bleibe mal bei meiner Vorrangehensweise und erkläre ihm lieber wo seine Fehler sind. Alles andere macht für mich keinen Sinn.

dask - Deine Antworten sind zumindest schon einmal nicht schlecht. Ich habe dir die Fragen gestellt um selber erst mal zu sehen ob du auch selber verstehst was du da gepostet hast. Prinzipiell scheinst du ja schon mal gewisse Grundlogik und ein allgemeines Verständnis von Progammabläufen zu haben. Sprich: Geordnete Gedankengänge von "Was will ich erreichen?" zu "Wie setze ich das um?". Das ist schon einmal eine gute Vorraussetzung. Nun zu deinen Fehlern die du mit dem Skript gepostet hast.

Frage 1:

Das ist soweit korrekt. Diese Zeile macht auch genau das, was du beschrieben hast.

Frage 2:

Das ist prinzipiell auch korrekt. Zumindest wenn es um die Logik dahinter geht. Jedoch ist das nicht korrekt umgesetzt. In der Programmierung existieren Strings. Strings sind auf gut Deutsch eigenlich nur Zeichenketten. In AutoIt werden Strings üblicherweise in " oder ' Zeichen verpackt. Was du tatsächlich abfragst ist Folgendes: Ist $iColor nicht gleich der Zeichenkette "Hex(C9C9C7)"? Du fragst hier nach der Zeichenkette ab, nicht nach dem Hexwert C9C9C7. Das ist schon ein Fehler. Was du eigentlich machen möchtest ist das hier: $iColor <> 0xc9c9c7

Um einen Hexdezimalen Wert in AutoIt darzustellen, kannst du einfach 0x vorne heran fügen. Die Funktion Hex() gibt dir den Hexdezimalen Wert einer Dezimalzahl zurück. Konvertiert also von Dezimalsystem zu Hexdezimalsystem. Der Rückgabewert ist allerdings ebenfalls ein String. AutoIt ist sehr freundlich was Datentypen angeht, meistens jedenfalls. Bedeutet dass "123" und 123 für AutoIt in Vergleichen das Selbe ist.

Hex() - Dokumentation

Frage 3:

Das Grundprinzip von Schleifen scheinst du zu kennen. Die Formulierung ist etwas üppig und nicht wirklich korrekt, aber ich sehe was du damit ausdrücken möchtest. Vom Sinn her ist das richtig.

---

Nun kommt der Knackpunkt in deinem Skript. Du fragst lediglich einmalig ab, welche Farbe an der Koordinate (738 | 822) befindet. Diese Farbe wird in $iColor gespeichert. Danach überprüfst du ob sich $iColor irgendwann einmal verändert. Das Problem ist allerdings, du fragst niemals nochmal nach der Farbe an besagter Koordinate. Heißt, dein $iColor bleibt immer gleich und deine Abfrage in der While-Schleife gibt demnach immer das Selbe Ergebnis zurück. Um das zu umgehen musst du $iColor in der While-Schleife aktuallisieren.

---

Andy - Tja, da warst du mal wieder schneller... x)

Hi o/
Willkommen im Forum!

Dein Code funktioniert nicht weil es einige Fehler beinhaltet. Wir geben hier normalerweise Hilfe zur Selbsthilfe, das bedeutet du bekommst (zumindest von mir) die grobe Richtung vorgegeben. Den Rest must du dir aber selber erschließen.

Da es dir wahrscheinlich an Grundlagen mangelt, fangen wir doch einfach mal mit einem einfachen Fragespiel an:

Was macht Local $iColor = Hex(PixelGetColor(738,822,1),6)?

Was macht While $iColor <> "Hex(C9C9C7)"?

Was ist eine While-Schleife?

Und zu letzt: Was möchtest du eigentlich erreichen?

Zitat von AspirinJunkie

Kannst du das genauer erläutern?

Ich meine damit dass es keinen generellen Parser gibt den du für jede Programmiersprache einfach nutzen kannst. Einen JSON Parser in Form einer DLL zum Beispiel. Stattdessen hat jede Programmiersprache eine eigene Implementation dafür.

https://www.json.org/json-en.html

Scroll mal runter auf der Seite, da fängt es schon an. Sagen wir mal, ich hab jetzt eine Programmiersprache die keinen JSON Parser von sich aus hat, viel spaß den Parser zu schreiben.

Zitat von BugFix

Ich hatte keineswegs die Absicht, dein Werk madig zu machen

Huh, davon bin ich auch nicht ausgegangen. Text im Internet ist sowieso immer schwierig zu interpretieren wenn es um die momentane emotionslage des Author geht.

Hauptsächlich sollte mein Beispiel demonstrieren wie das Dateiformat funktioniert, nicht welche Vorteile es gegenüber anderen bietet und welche Nachteile. Darum geht es auch gar nicht. Das ist nur entstanden da ich einen spezifischen Anwendungsfall hatte wo vorhandene Dateiformate schlichtweg versagen oder es eben kein Parser dafür existiert für meine genutzte Programmiersprache. Beispiel JSON - Es gibt zwar zig implementationen, diese sind aber alle Programmiersprachen spezifisch.

Welp, es musste was her was extrem einfach zu parsen ist. Letzten endes ist das ganze gestern Nacht in einer halben Stunde entstanden. xD

Zitat von BugFix

Vielleicht solltest du mal eine Bsp. generieren, dass die erforderliche Flexibilität beinhaltet. Das hier gezeigte Bsp. ist (deutlich einfacher lesbar) auch in einer INI abbildbar.

Verstehe dein Einwand nicht. Die INI Datei zwingt dich in folgendes Format:

[Section]

Key=Value

Kommentare müssen mit einen ; am Zeilenanfang beginnen

Zumal es auch nicht möglich ist folgendes zu machen:

[Section]

Key==Value

Wie kann ich den Key jetzt "Key=" nennen und den Value auf "Value" setzen?

Kurz, die INI und dazugehörigen AutoIt Funktionen schränken dich ein. Mein Format soll eben das Problem umgehen. Es geht hauptsächlich darum die Einschränkungen, wie die Datensätze in der Datei hinterlegt werden müssen, lockerer zu gestalten. Ich hab meine Gründe dazu und auch sogar ein Anwendungsfall wo die INI schlichtweg versagt. Ich dachte ich teile meine Gedanken dazu weil ein Parser für diese Variante schnell geschrieben ist.

Hallo o/

Aus verschiedenen Gründen brauchte ich ein Dateiformat, welches Hauptsächlich Konfigurationen speichert. Mein erster Gedanke war logischerweise eine simple *.ini Datei. Jedoch war das Format leider noch viel zu unflexibel für mein Vorhaben. Andere Dateiformate waren und sind auch viel zu kompliziert (z.B. JSON) um schnell mal einen Parser dafür zu schreiben. Also hatte ich mir überlegt, wie kann man ein Dateiformat so simpel wie möglich halten und dennoch sämtliche Möglichkeiten offen halten?

Lustigerweise hatte ich dann auch eine Idee. Der Parser dazu war auch schnell geschrieben (obwohl dieser sicherlich mit String Funktionen um einiges schneller wäre). Ich nenne das Format Yjuq's File Format oder kurz: YFF - *.yff

Das Prinzip dieses Formates ist extrem simpel. Du wählst dir dein Delimeter und Escape Zeichen aus. Man kann sich auch mehrere aussuchen. Zu einfachen Demonstationszwecken benutze ich folgende:

Delimeter: < und >

Escape: \

Alles was zwischen den Delimeter ist wird als Datensatz gewertet, alles was direkt nach einem Escape Zeichen in einem Datensatz kommt, wird ebenfalls als Datensatz gewertet. Das bedeutet dass die Escape Zeichen hauptsächlich dazu dienen, ebenfalls die Delimeter als Datensatz zu erkennen. Logischerweise kannst du damit auch Escape Zeichen als Datensatz werten lassen. Alles andere, was nicht zwischen Delimeter steht, wird schlichtweg ignoriert.

Dieses Dateiformat erlaubt es das Dateiformat frei zu bestimmen und dennoch die Datensätze zu deklarieren. Die ignorierten Zeichen können als Kommentare genutzt werden oder für weitere Datensätze für andere Delimeter und Escape Einstellungen. Da bleibt es eurer Fantasie überlassen.

--------------------------------------------------------------------------------

Das ist ein Beispiel für ein valides Dokument. Da alle Zeichen bis auf die
Zeichen zwischen [Delimeter] ignoriert werden, kann ich hier schlichtweg den
Platz für Dokumentationszwecke nutzen.

--------------------------------------------------------------------------------

Hier ein Beispiel für ein Datensatz: <Ich bin ein Datensatz>

Da "Ich bin ein Datensatz" zwischen 2 Delimeter geschrieben wurde, wird dies als
gültiger Datensatz erkannt.

--------------------------------------------------------------------------------

Hier ein weiteres Beispiel: <\<Daten\>>

Dies würde euch den Datensatz "<Daten>" ausgeben.
                                ^^^^^
                      Da dies nicht escaped wurde, ist das auch ein Datensatz ^^

--------------------------------------------------------------------------------

In:     <data<
Out:    "data"

In:     >data>
Out:    "data"

In:     <da\ta>
Out:    "data"

In:     <da\\ta>
Out:    "da\ta"

--------------------------------------------------------------------------------

Ich denke das Prinzip ist klar.

Hier einmal ein Beispielskript mit dem Parser dazu:

#include <Array.au3>

Local $string = FileRead("example.yff")
Local $array = yffParse($string)

_ArrayDisplay($array)

; $string     -> Der zu parsende String
; $del        -> Array im folgenden Format:
;                > [0] = Anzahl der Delimeter Zeichen
;                > [1] = Asc(Delimeter 1)
;                > [2] = Asc(Delimeter 2)
;                > [x] = Asc(Delimeter x)
; $esc        -> Array im folgenden Format:
;                > [0] = Anzahl der Escape Zeichen
;                > [1] = Asc(Escape 1)
;                > [2] = Asc(Escape 2)
;                > [x] = Asc(Escape x)
Func ycfParse($string, $del = Default, $esc = Default)
    If $del = Default Then
        Dim $del[3]
        $del[0] = 2
        $del[1] = Asc("<")
        $del[2] = Asc(">")
    EndIf

    If $esc = Default Then
        Dim $esc[2]
        $esc[0] = 1
        $esc[1] = Asc("\")
    EndIf

    Local $str = StringToASCIIArray($string, 0, StringLen($string), 1)
    Local $dat[2] = [1]
    Local $mod, $flg

    For $i = 0 To UBound($str) - 1
        Switch $mod

            ; searching for delimeter or escape
            Case 0

                ; check for delimeter
                If yffCheck($str[$i], $del) Then $mod = 1

                ; check for escape
                If yffCheck($str[$i], $esc) Then $mod = 2

            ; getting the data
            Case 1

                ; check for delimeter
                If Not $flg And yffCheck($str[$i], $del) Then
                    $mod = 0

                    ; check for array size
                    $dat[0] += 1
                    If $dat[0] = UBound($dat) Then ReDim $dat[($dat[0]) * 2]
                Else

                    ; check for escape
                    If Not $flg And yffCheck($str[$i], $esc) Then
                        $flg = True
                    Else
                        $dat[$dat[0]] &= Chr($str[$i])
                        $flg = False
                    EndIf
                EndIf

            ; skip one
            Case 2
                $mod = 0
                $flg = False
        EndSwitch
    Next

    ; crop array
    ReDim $dat[$dat[0]]
    $dat[0] -= 1

    Return $dat
EndFunc

Func yffCheck($char, $sym)
    For $i = 1 To $sym[0]
        If $char = $sym[$i] Then Return True
    Next
EndFunc

Der Parser selber schmeißt euch einfach eine Liste mit allen Datensätzen zu. Im Index 0 ist immer die Anzahl der Datensätze im Array. Wie Ihr die Datensätze interpretiert bleibt euch überlassen. Hier mal ein einfaches Beispiel um Daten im Key = Value Format zu speichern:

--------------------------------------------------------------------------------

Die "=" Zeichen im Dokument dienen nur für die Lesbarkeit des Menschen. Sie
haben für den Parser absolut keine Bedeutung da diese außerhalb der Delimeter
liegen. Sie werden also schlichtweg ignoriert...

--------------------------------------------------------------------------------

<Key 1> = <Value 1>
<Key 2> = <Value 2>

<Key 3>        Kommentar zu "Key 3"
<Value 3>      Kommentar zu "Value 3"

--------------------------------------------------------------------------------

Und hier das Skript:

#include <Array.au3>

Local $string = FileRead("example.yff")
Local $array = yffParse($string)
Local $keyvalue[$array[0] / 2][2]

; Map 1D Array to 2D Array | Key=Value Format
For $i = 1 To $array[0] / 2
    $keyvalue[$i - 1][0] = $array[$i * 2 - 1]
    $keyvalue[$i - 1][1] = $array[$i * 2]
Next

_ArrayDisplay($keyvalue)

Func yffParse($string, $del = Default, $esc = Default)
    If $del = Default Then
        Dim $del[3]
        $del[0] = 2
        $del[1] = Asc("<")
        $del[2] = Asc(">")
    EndIf

    If $esc = Default Then
        Dim $esc[2]
        $esc[0] = 1
        $esc[1] = Asc("\")
    EndIf

    Local $str = StringToASCIIArray($string, 0, StringLen($string), 1)
    Local $dat[2] = [1]
    Local $mod, $flg

    For $i = 0 To UBound($str) - 1
        Switch $mod

            ; searching for delimeter or escape
            Case 0

                ; check for delimeter
                If yffCheck($str[$i], $del) Then $mod = 1

                ; check for escape
                If yffCheck($str[$i], $esc) Then $mod = 2

            ; getting the data
            Case 1

                ; check for delimeter
                If Not $flg And yffCheck($str[$i], $del) Then
                    $mod = 0

                    ; check for array size
                    $dat[0] += 1
                    If $dat[0] = UBound($dat) Then ReDim $dat[($dat[0]) * 2]
                Else

                    ; check for escape
                    If Not $flg And yffCheck($str[$i], $esc) Then
                        $flg = True
                    Else
                        $dat[$dat[0]] &= Chr($str[$i])
                        $flg = False
                    EndIf
                EndIf

            ; skip one
            Case 2
                $mod = 0
                $flg = False
        EndSwitch
    Next

    ; crop array
    ReDim $dat[$dat[0]]
    $dat[0] -= 1

    Return $dat
EndFunc

Func yffCheck($char, $sym)
    For $i = 1 To $sym[0]
        If $char = $sym[$i] Then Return True
    Next
EndFunc

Nun denn, für meine Zwecke jedenfalls nutzbar. Ich dachte ich teile das mit euch. Wer einen besseren Parser schreiben möchte, nur zu. Ich hantiere mit eine kleine Menge an Daten dh. reicht mir die Geschwindigkeit aus. Jedoch würde ich mich natürlich über ein free update freuen.

Hauptsächtlich geht es bei dem Post darum eine einfache Möglichkeit zu haben Datensätze in menschenlesbarer Form zu speichern und abzurufen. Dabei sollte das Format nicht kompliziert sein aber funktionsreich genug um auch Datensätze zu erzeugen die via Software dann richtig aufbereitet werden können. Eine einfache Array Liste reicht da meiner Ansicht nach aus. Darauf lassen sich weitere Filter und Bedingungen anknüpfen um das Dateiformat zu extenden. Sprich: Datensätze weiter auswerten und entsprechend so zu kategorisieren wie gewünscht.

Hi, ich hab keine Ahnung von Nim aber von das bisschen was ich mir gerade zusammengesucht habe würde ich einfach aus der WinAPI die 3 klassischen Funktionen LoadLibraryA, GetProcAddress und FreeLibrary nutzen. In GetProcAdress kannst du nämlich die Ordnungszahl benutzen.

https://rosettacode.org/wiki/C…Interacting_with_Nim_code

Vielleicht hilft das ja.

Hey, guck mal hier: https://www.autoitscript.com/f…ge-runtime-clr-framework/

Damit kannst du auf die .NET DLL zugreifen. Alternativ kannst du auch einen eigenen Treiber schreiben. Ich bezweifel dass es dazu schon eine Ansteuerung in AutoIt existiert.

Ich bin jedoch ein wenig Suchfaul, wenn du mir den Sourcecode zu der .NET DLL liefern kannst, kann man damit bestimmt was machen.

https://www.plenom.com/downloads/download-software/#sdk - Da ist auch eine USB API dabei, guck mal ob du damit nicht was anfangen kannst.

Zitat von alpines

Braucht definitiv noch ein bisschen Arbeit aber wow, sieht richtig gut aus, gefällt mir sehr gut.

Kleiner Tipp: Nimm als Berechnung der Zeichenstrecke nicht die Iteration * Schritt, da diese unterschiedlich oft ausgeführt wird auf stärkeren/schwächeren PCs.

Erstell dir eine Timer-Variable und setze sie mit jeder Schleifeniteration neu und speichere dabei die Differenz zur letzten Schleife.

Dann normalisierst du den Wert auf eine Sekunde bspw. und multiplizierst ihn mit dem Faktor den ein Kreis zurücklegen soll pro Sekunde.

Dann ist das ganze FPS unabhängig.

Alles anzeigen

Ich hatte dazu mal einen Beitrag geschrieben: RE: PandaRunner Reworked - Ein Autoit Game

Für jene die es interessiert.

Woha, ich mag die Idee. Ich glaube ich mache mir daraus ein Live Wallpaper.

Ich werde da auch mal ein an einer Version basteln. Gerne Teile ich dir dann meine Lösungsansätze mit. Wenn du ggf. Grafiken brauchst könnte ich welche machen. Dauert nur je nachdem wie ich Lust & Zeit habe.

Naja, du kannst den Datenverkehr im USB port mitschneiden wenn du lust hast. Würde daraus hinauslaufen dass du dann einen eigenen Treiber für das Gerät schreibst. Ich bezweifel dass der Hersteller des kartenlesegerätes irgendwo eine öffentliche Dokumentation dafür hast, also müsstest du schon selber herausfinden müssen wie das Gerät die Daten überträgt.

Die einfachste und schnellste Lösung:

Zitat von autoBert

Druck doch einfach in eine Datei. Diese kannst du dann so aufarbeiten wie du es benötigst.

Aber ja, prinzipiell könntest du das mit AutoIt lösen... Mit genug Aufwand. xD

Ehrlich gesagt bin ich da gerade ziemlich dran interessiert. Einen Treiber habe ich bis dato noch nicht geschrieben. Wenn du die Zeit & Lust hast können wir es ja mal versuchen. Ich habe halt nur nicht den Kartenleser hier, weshalb sämtliche Tests du übernehmen müsstest.

Zitat von Tweaky

Was ist der Unterschied zwischen _WinAPI_PathFindFileName und _WinAPI_PathStripPath.

Beides mal bekomme ich doch den Dateinamen als Ergebnis.

Hi Tweaky, es ist richtig dass beides prinzipiell das gleiche Ergebnisse liefern. Der Hauptunterschied ist jedoch dass die WinAPI in PathFindFileName einen String zurückgibt (genauer gesagt einen Pointer). PathStripPath hingegen überschreibt den angegebenen String. Das ist in etwa das Äquivalent zu ByRef in AutoIt.

Local $ref = "c:\doc\test.bin"
ConsoleWrite(PathFindFileName($ref & @CRLF))

PathStripPath($ref)
ConsoleWrite($ref & @CRLF)

Func PathFindFileName($string)
    Local $split = StringSplit($string, "\")
    Return $split[$split[0]]
EndFunc

Func PathStripPath(ByRef $string)
    $string = PathFindFileName($string)
EndFunc

So ungefähr. AutoIt jedoch hat bei der PathStripPath Variante schlichtweg einfach einen Rückgabewert stattdessen hinzugefügt. Warum jedoch beide Funktionen in der WinAPI existieren kann ich dir nicht sagen, das wird mir aus der Dokumentation nicht ersichtlich.

https://docs.microsoft.com/en-…shlwapi-pathfindfilenamea

https://docs.microsoft.com/en-…nf-shlwapi-pathstrippatha

Gruß

Ich würde dir vorschlagen deinen Post nochmal durchzulesen und zu überlegen, ob dir irgendwer anhand dieser Beschreibung helfen kann. Am einfachsten ist es eigentlich immer Fragen hier im Forum folgendermaßen zu stellen:

--

Hi,

Ich möchte gerne folgendes umsetzen:

- Beschreibung 1

- Beschreibung 2

- Beschreibung 3

- etc...

Folgendes habe ich versucht bzw. das sind meine Lösungsansätze:

- Versuch 1

- Versuch 2

- Versuch 3

Hier noch einige Screenshots / Quellcode / zusätzliches Material:

- Daten 1

- Daten 2

- Daten 3

Hat jemand eine Idee wie ich das am besten umsetze?

---

Das hilft uns erst einmal zu verstehen wo genau das Problem liegt und ob dein Lösungsansatz überhaupt der passende für dein eigentliches Vorhaben ist. Zumal liefert es auch die notwendigen Informationen um dir konkret helfen zu können. Es ist auch immer gut schon vorab Background Informationen zu liefern. Das heißt, was möchtest du machen? Wieso willst du das machen? An welche Parameter sind wir gebunden, wo können wir ggf. andere Dinge vorschlagen (vielleicht ein anderes Programm benutzen)? etc...

Kannst du ggf. meine Frage mit diesen Informationen beantworten?

--> Ich habe ein Rezept. Dort ist als Zutat Äpfel gelistet. Ich habe keine Äpfel, mit was kann ich diese ersetzen?

Zitat

Wie komme ich dennoch an die notwendigen / versteckten Infos, um dann die jeweiligen Buttons/Boxen ganz gezielt anzusteuern?

Keine Ahnung. Das liegt an dem Programm was es anzusteuern gilt. Im schlimmsten Fall existiert ja immernoch _ImageSearch().

---

Tendenziell ignoriere ich in den meisten Fällen Fragestellungen, welche mir nicht direkt mitteilen können was sie wollen. Erfahrungsgemäß bin ich da länger dran beschäftigt die notwendigen Informationen einzuholen, als an einer Lösung zu arbeiten.

Das ist auch nicht böse gemeint. Es hilft uns direkt ein klares Bild zu bekommen was der Fragestellende möchte. Zudem hilft es dir jemanden schneller zu finden der deine Frage auch beantworten kann.

Oh OHHH. Bitte leitet mir diese E-Mails mal weiter. Ich liebe es an solche Mails zu antworten und scammer Ihre Zeit zu rauben. Da kommen immer die witzigsten Sachen bei raus.

yjuq@sharklasers.com

Das liegt daran dass Windows gerne mal solche Dateien daran hindert den Content zu laden. Das lässt sich ziemlich einfach beheben.

Dazu gehst du einfach in dein AutoIt Installationsverzeichnis (Standardmäßig: C:\Program Files (x86)\AutoIt3) und machst ein Rechtsklick auf der Datei AutoIt.chm. Dort wählst du die Eigenschaften aus.

Dort müsstest du folgendes sehen können:

Dort einfach auf Zulassen klicken und mit OK oder Übernehmen das ganze speichern.

Gern geschehen.

€dit:

RIP... Da gibt man sich mal halbwegs mühe. xD