1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. Andy

Beiträge von Andy

  • ortogonale Zuordnung von Varibalen

    • Andy
    • 17. Juli 2016 um 09:19
    Zitat von Alina

    asm? ich dachte immer, das es ASM nicht mehr gibt und nur noch von "alt gesessenen" genutzt wird.

    fast richtig, "alt Eingesessene" gab es schon immer, genau wie es schon immer einen Grund gab, die vorhandene Hardware optimal auszunutzen. Assembler hat aber ganz- und garnichts mit "alt" zu tun, gerade im Gegenteil, wenn man moderne Features von Prozessoren nutzen will/muss, bleibt einem meist nichts anderes übrig als mit Assembler zu programmieren da die "modernen" Compiler viele Prozessorbefehle (noch) nicht implementiert haben.

    Es ist schon seltsam, noch nie gab es so schnelle Prozessoren wie heute, und trotzdem steigt der Anteil an Assemblerprogrammen (auch Programmierern?! ) in letzter Zeit wieder an:
    http://www.heise.de/developer/meld…in-3263014.html

    Viele Programmierer müssen sich aber mit Blick auf die Ausführungsgeschwindigkeit ihrer Programme absolut keine Gedanken machen, der Prozessor dümpelt sowieso meist nur im Idle rum, der schnellste Tastaturakrobat schafft es nicht mal, einen Prozessor aus dem Schlafmodus zu holen.
    Such mal nach "Prozessorlast" hier im Forum, da wird der Irrsinn offensichtlich! Da werden >4Ghz Prozessoren gekauft, damit man "Leistung" hat, und wenn bei diesen Prozessoren die Last über 3% steigt, fängt das große Zittern an. Da werden dann "Sleep()"-Befehle eingebaut, damit das Hochleistungsgerät bei 1%%% der Maximalleistung arbeitet.
    Dort, wo Code mit Blick auf Geschwindigkeit oder/und Größe optimiert werden MUSS, wird immer noch Assembler eingesetzt, s. bspw. hier: https://en.wikipedia.org/wiki/Assembly_…e#Current_usage


    [OT]
    Wenn ich einen Blick in die Zukunft von Assembler werfe, dann sehe ich dessen Ende auf den gängigen Rechnerarchitekturen (seitens Otto-Normal-Programmierern). Es wird bald soweit sein, dass Code nur noch in "abgeschotteten" Bereichen im Speicher laufen wird, der nicht einmal Zugriff von Disassemblern/Debuggern erlaubt. Das Märchen von den Vorteilen von Open-Source wie "Freiheit, offene Quellen, finden von Bugs und Anpassung auf eigene Bedürfnisse" ist seit Jahren schon ausgeträumt, 85% der Nutzer geben keine/geringere Lizenzkosten als Hauptaugenmerk für die Verwendung von Open-Source an. Von diesen 85% hat nicht mal 1% auch nur die Möglichkeit, Sourcecode auszuwerten, geschweige denn zu optimieren/verbessern/auf eigene Bedürfnisse anzupassen!
    Die Zukunft wird aus völlig "zugenagelten" Rechnern bestehen, die unter der absoluten Kontrolle der Hersteller (Hardware und BS) stehen. Dem User wird ein kleiner Bereich gestattet in dessen eng gesteckten Grenzen er agieren darf, da wird es keine eigenen Bootloader/Treiber/Systemprogramme mehr geben. Brave new world...[OT]

    Zitat von Alina

    paar "Aufrufe" gibt, die abzuleiten sind vom "Batch'en / Dos'sen", aber das war es auch.

    naja, mit BATCH/DOS hat das absolut nichts zu tun, mov, cmp, usw. sind Prozessorbefehle, welche mit den Prozessor-Registern arbeiten. Also direkt am offenen Herzen des Rechners. Kein Netz, kein doppelter Boden, jeder kleinste Fehler führt zum Crash!


    Zitat von Alina

    Irgendwann hat man mir mal diese Sachen XOR / OR / AND / AND OR versucht zu erklären an Hand von
    Lichtschaltern.

    https://de.wikipedia.org/wiki/Logikgatter
    Wenn man die Funktion begriffen hat, bieten sich dem Programmierer in einigen Situationen große Vorteile bzgl. Codelänge und Geschwindigkeit. Guck mal in die AutoIt-Beispiele, in denen Styles und ExStyles verwendet werden, je nach Anwendung spart da ein einziger BitOR()-Befehle viele Zeilen Code.
    Man hat bspw. auch die Möglichkeit, die Zustände von 32(64) Checkboxen/Lichtschaltern in einer einzigen 32(64)-Bit-Variablen zu speichern.

    AutoIt
    $schalter = 2009356218             ;eine variable
    For $i = 0 To 31                   ;32 Zustände
        If BitAND($schalter, 2 ^ $i) Then
            $zustand = "an"
        Else
            $zustand = "aus"
        EndIf
        ConsoleWrite("Lichtschalter " & $i & " ist " & $zustand & @CRLF)
    Next
    
    
    ConsoleWrite(@CRLF & @CRLF)
    
    
    ;oder "neumodischer" mit ternären Operatoren
    For $i = 0 To 31                   ;32 Zustände
        ConsoleWrite("Lichtschalter " & $i & " ist " & (BitAND($schalter, 2 ^ $i) ? "an" : "aus") & @CRLF)
    Next
    Alles anzeigen
  • Unsaubere Grafikdarstellung

    • Andy
    • 16. Juli 2016 um 15:36
    Zitat von Oscar

    Merkwürdigerweise wird das Bild aber korrekt dargestellt, wenn man erst die GUI anzeigt (GUISetState) und dann das Bild erstellt (GUICtrlCreate).

    Nein, denn das auch nur, wenn GUISetBkColor() VOR dem GUICtrlCreate() aufgerufen wird...

    Die "roten" Störpixel habe ich nur an den Pixeln, deren Orginalfarbe 0xF0F0F0 ist. Ob es beim Setzen des Backgrounds ein Problem (Little/Big Endian) mit dem von dir in der linken oberen Ecke angegebenen "transparenten" Pixel (denn das ist 0x0F0F0F) gibt, sollte man mal verifizieren. Wer dann noch Zeit und Muße hat, kann ein Ticket erstellen...

  • ortogonale Zuordnung von Varibalen

    • Andy
    • 16. Juli 2016 um 15:02
    Zitat von Alina

    Das würde bedeuten, das ich als ersten die Primzahlen in ein Arry schreibe. Danach eine zufällige
    Zahl zwischen 1 und 1065 auswählen. Das Array ist dann die erste Primzahl. Danach 6x immer
    plus 1065 und schon habe ich die 7 Primzahlen.

    So kompliziert würde ich das garnicht machen....
    Die Primzahlen hast du doch sowieso schon, also ist die zufällige Primzahl doch $primzahl=$primzahlenarray[random(1,ubound($primzahlenarray)-1,1)), welche du einfach an eine zufällige Position im Spielfeld schreibst.
    Dann brauchst du nur noch eine Funktion _Test_auf_Schwarzer_Peter(). Wenn diese eben geschriebene Primzahl einen weiteren "Schwarzen Peter" verursachen würde, dann setze sie einfach an eine andere Position.....

  • ortogonale Zuordnung von Varibalen

    • Andy
    • 16. Juli 2016 um 14:35

    :D !

    Ich dachte aber eher an diese (meine) Funktion 8o


    AutoIt
    #AutoIt3Wrapper_UseX64=n
    
    
    ;~ #include <assembleit2_64.au3>
    
    
    
    
    Local $maximum = 99999   ;50000000        ;1299709
    
    
    $t = TimerInit()
    $primzahlen = _PrimeAsm($maximum) ;Assembler aufrufen, code assemblieren, in den Speicher schreiben und ausführen
    $m = TimerDiff($t)
    
    
    
    
    StringReplace($primzahlen, @CR, @CR, 0, 1) ;alle CR im String zählen.....auch AutoIt hat SPEEEEED^^
    $anzahlprim = @extended  ;hätte man auch vom Assembler zurückgeben lassen können^^
    
    
    MsgBox(262144, "Primzahlen bis " & $maximum, $anzahlprim & " Primzahlen in " & Int($m) & " Millisekunden, Ausgabe der Zahlen folgt in Console....")
    ConsoleWrite($primzahlen & @CRLF)
    
    
    
    
    FileDelete("Primzahlen_asm.dat")
    FileWrite("Primzahlen_asm.dat", $primzahlen)
    ShellExecute("Primzahlen_asm.dat")
    
    
    
    
    
    
    Exit
    
    
    
    
    
    
    
    
    Func _PrimeAsm($limit)   ;code by Andy@AutoIt.de
    
    
        Local $tStruct = DllStructCreate("uint Limit;uint Limes;char Mem[" & $limit + 10 & "]") ;char, dann kann man nachher schön mit den stringfunktionen suchen
        DllStructSetData($tStruct, "Mem", "001") ;die ersten 3 Zahlen setzen, 0=0 1=0 2=1 , 2 ist die erste Primzahl")
        DllStructSetData($tStruct, "Limit", $limit) ;limit in die Struct schreiben
        DllStructSetData($tStruct, "Limes", Floor(Sqrt($limit)) + 1) ;wurzel aus limit in die struct schreiben
    
    
    
    
        Local $asm_code = "0x558B6C24088B5D00B803000000C74405083130313083C00439D876F18D7D0889FE8B4D00BB0300000089D8F7E0C604063001D839C87EF683C30239CB7736803C1E3175F3535189D8BB0A00000031C931D2F7F3665280C10109C075F366580C30AAE2F9C6070D83C701595B3B5D047CB939CB7CC3C607005DC3"
    ;~     $asm_code = _AssembleIt2("retbinary", "_primzahlen", "ptr", DllStructGetPtr($tStruct)) ; Assembler aufrufen, um code für dllcalladdress zu bekommen
    ;~     ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $asm_code = ' & $asm_code & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    
    
        Local $asm_struct = DllStructCreate("byte[" & StringLen($asm_code) / 2 - 1 & "]") ;speicher für asm-code bereitstellen...
        DllStructSetData($asm_struct, 1, $asm_code) ;...und mit code beschreiben
    
    
        DllCallAddress("none:cdecl", DllStructGetPtr($asm_struct), "ptr", DllStructGetPtr($tStruct)) ;asm-code aufrufen
    
    
    ;~     $Ret = _AssembleIt2("uint", "_primzahlen", "ptr", DllStructGetPtr($tStruct)) ; Assembler aufrufen, wenn man das dllcalladdress-gedöns garnicht braucht
    ;~     ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $Ret = ' & $Ret & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
        $pstring = "2" & @CR & "3" & @CR ;2 und 3 sind die ersten Primzahlen
        $pstring &= DllStructGetData($tStruct, "Mem") ;alle Primzahlen aus der struct in den string schreiben
    
    
        Return $pstring      ;und zurückgeben
    
    
    EndFunc                  ;==>_PrimeAsm
    
    
    
    
    #cs _primzahlen
    
    
        use32
    
    
        push ebp             ; ebp des aufrufenden Programms retten
        mov ebp, dword[ESP+08h]  ; "unseren" ebp setzen auf den Anfang unserer Struct
        ;dann ist...
        ;    [EBP+0h]  der erste Parameter (Limit) , da UINT ist er 4 Bytes lang, daher ist der nächste Parameter bei...
        ;    [EBP+04h] der 2 Parameter (Limes), auch 4 Byte lang...daher findet man den 3. Parameter, unsere struct bei...
        ;    [EBP+08h] der Anfang des Speicherbereichs Mem
        ;ich verwende die Hex-Zahlen, um bei verschiedenen Assemblern einen Standard zu haben, der Windowstaschenrechner ist Gold wert^^
    
    
        mov ebx,dword[ebp+0h]  ; Limit
        mov eax,3            ; 3 ist die nächste Primzahl
    
    
    
    
        Fill:                ; Schleifenanfang
        mov dword[ebp+08h+eax],30313031h    ; an die Speicherstelle in der Struct den String "1010"
        add eax,4            ; eax=eax+4        ;geht auch mit einem rep stosw^^                10
        cmp eax,ebx          ; vergleiche eax mit $limit
        jbe Fill             ; Jump if below or equal (wenn <=) nach Fill, ansonsten weiter
        ;in der struct steht nun 001101010101010101010.....alle vielfachen von 2 sind 0, die erste 0 ist die 0, 2 ist die erste Primzahl!
    
    
        ;startadresse Struct Prim holen
        ;~     mov edi, ebp                  ; an ebp steht der erste Parameter, wir brauchen aber die Adresse von ebp+8
        ;~     add edi, 8                    ; ebp+8 ist die adresse des ersten bytes der struct Mem
        lea edi,[ebp+8]
        mov esi, edi         ; ESI=anfang Mem
        mov ecx,dword[EBP+0h]  ; do until limit
        mov ebx,3            ; ebx=aktuelle Zahl in der struct struct[1]=speicher[0] !!!!!!
        L0:
        mov eax,ebx          ; eax=ebx=aktuelle primzahl
        mul eax              ;nächstes vielfaches der prim = quadrat der primzahl
        ;****************************************
        ;ACHTUNG, das Erbebnis von mul ist EDX:EAX also wird auch das edx-register verändert!
        ;*****************************************
        L1:
        mov byte[esi+eax],30h  ;jedes vielfache der Primzahl in der struct zu "0" machen
        add eax,ebx          ;eax=eax+ebx vielfaches der Primzahl        20
        cmp eax,ecx          ; Vielfaches mit limit vergleichen
        jle L1               ; solange eax < limit, die Vielfachen löschen
        L2:                  ;nächste Primzahl holen
        add ebx,2            ;2 zahlen weiter springen ,3,5,7,9,11,13,15....
        cmp ebx,ecx          ;dword[EBP+0h]           ; vgl aktuelle position mit dem Ende von Mem
        ja exit              ;wenn Ende erreicht, exit
        cmp byte[esi+ebx],31h  ;ist an dieser stelle in der struct eine primzahl?
        jne L2               ;wenn nicht, nächste zahl wählen
        ;************************************************************
        ;aus einer Zahl(Registerinhalt) einen ZiffernString machen: http://dcla.rkhb.de/umwandlung/int2dez.html
        ;und in die Primstruct schreiben
        ;wird dieser Bereich auskommentiert, wird ein String aus nullen und einsen zurückgegeben 0=keine Prim 1=Prim
        ;dann können mit den AutoIt-Stringbefehlen die Primzahlen und deren Anzahl ausgelesen werden
        push   ebx           ;alle benötigten Register sichern
        push   ecx           ;alle benötigten Register sichern
        mov eax, ebx         ;Zahl laden
        mov ebx, 10          ; Divisor
        xor ecx, ecx         ;ECX=0 (Anzahl der Ziffern)
        Schleife_1:
        xor edx, edx
        div ebx              ; EDX:EAX / EBX = EAX Rest EDX
        push dx              ; LIFO
        add cl,1             ; ADD soll schneller sein als INC
        or  eax, eax         ; AX = 0?
        jnz Schleife_1       ; nein: nochmal
        Schleife_2:
        pop ax               ; gepushte Ziffern zurückholen
        or al, 00110000b     ; Umwandlung in ASCII
        stosb                ; Nur AL nach [EDI] (EDI ist ein Zeiger auf den String)
        loop Schleife_2      ; bis keine Ziffern mehr da sind
        mov byte [edi],0Dh   ;CR  CarriageReturn, man könnte auch ein Komma (ascii=2C) einsetzen, dazu noch ein nullbyte als EndOfString
        add edi,1            ;ein Byte weiter
        pop   ecx            ;Register wiederherstellen
        pop   ebx            ;Register wiederherstellen
        ;************************************************************Ende Ziffer aus Register
    
    
        cmp ebx,dword[EBP+04h] ; vgl aktuelle position mit der wurzel der listengrösse
        jl L0                ; solange ebx < wurzel listengrösse, gehe vielfache eliminieren
    
    
        ;jetzt ist die Mem-Struct völlig gefüllt aber die Primzahlen sind nur bis Limes in der Prim-Struct!
        ;also muss der Rest auch noch eingetragen werden
        cmp ebx,ecx          ;dword[EBP+0h]           ; vgl aktuelle position mit dem Ende von Mem
        jl L2                ; solange ebx < limit, gehe vielfache eliminieren bzw "1"en in zifferfolgen umwandeln
    
    
        exit:                ;
        mov byte [edi],00h   ;nullbyte als EndOfString anfügen, damit hinter den Zahlen nicht die übrigen 0en und 1en stehen
        pop ebp              ; ebp des aufrufenden Programms restaurieren
    
    
        ret                  ; und zurück, in eax steht das Ergebnis
    
    
    #ce
    Alles anzeigen

    Das war mal eine "aus dem Ärmel" geschüttelte Version für ein µ-It, um den Faktor 1000 in der Geschwindigkeit gegenüber AutoIt auszutesten 8)
    Man beachte, es dauert wesentlich länger, die Daten aus dem Speicher in einen String zu schreiben bzw. in eine Datei, als die Primzahlen nach dem über 2000 Jahre alten Sieb des Erathosthenes zu ermitteln....wer mag, kann ja mal das Limit auf 50 Millionen setzen. Da dauert die Primzahlermittlung incl. die Umwandlung aller Primzahlen in einen String auf meinem Rechner ca. 2 Sekunden.

  • ortogonale Zuordnung von Varibalen

    • Andy
    • 15. Juli 2016 um 19:13

    Hallo Alina,

    wenn ich das richtig verstanden habe lautet die Spielanweisung:
    "Finde den schwarzen Peter, der keine Primzahl ist. In der Spalte des schwarzen Peter befinden sich GENAU 2 Primzahlen, in der Reihe des schwarzen Peter befinden sich GENAU 2 Primzahlen"

    Was ich nicht verstanden habe ist die Sache mit den 3 weiteren Primzahlen, deren Position imho völlig unerheblich dabei ist, den schwarzen Peter zu finden!

    Umzusetzen ist das ganze relativ einfach, du musst nur die 5 Punkte "schwarzer Peter" ausfüllen und dann dessen Reihe und Spalte ausfüllen, allerdings ohne Primzahlen!
    Dann wird das restliche Spielfeld (es ergeben sich 4 Quadranten) mit den übrigen Zahlen von oben nach unten ausgefüllt.
    Einzige Regel ab jetzt! Es darf keine NICHT-Primzahl geben, in dessen Reihe und Spalte jeweils eine Primzahl ist, denn das wäre automatisch ein "schwarzer Peter". Daher würde ich das Spielfeld "zufällig" mit den weiteren Primzahlen füllen, und zwar so, dass sich kein "schwarzer Peter" ergeben kann! Alle anderen "nicht-Primzahlen" kannst du nun gefahrlos auf die restlichen Felder verteilen, es wird sich nie ein schwarzer Peter ergeben....


    //EDIT
    Von 0 bis 99999 gibt es 9592 Primzahlen, die lassen sich selbst auf meinem langsamen Rechner innerhalb von 2-3 Millisekunden berechnen.
    Vorgehen also folgendermaßen:
    - Schwarzer_Peter_bestimmen (aus zufälliger nicht Primzahl und 4 Primzahlen)
    - im restlichen Spielfeld zufällig alle weiteren Nicht-Primzahlen verteilen
    - Damit es schwieriger wird, zufällig x (Schwierigkeitsgrad!) Primzahlen verteilen, dabei darauf achten, dass in deren Reihe und Spalte kein weiterer Schwarzer Peter entsteht.

  • Seltsames Leuchten in den Wolken

    • Andy
    • 15. Juli 2016 um 07:36
    Zitat von autoBert

    Open-Brain

    Brain....Brain....da war doch was [Blockierte Grafik: http://www.SmilieCenter.de/smilies/nachdenkliche/nachdenkliche_smilies_0008.gif]

  • Textfeld aktivieren

    • Andy
    • 15. Juli 2016 um 07:32

    Hi,

    schau mal nach, was man mit "AutoIt Window Info" macht. Mit diesem Programm bekommst du Informationen zu den sog. Controls eines Programms. Und diese Controls kannst du dann per GuiCtrlxxxxx-Befehlen (siehe Hilfe) bearbeiten, unter anderem bspw. Text in ein Textfeld einfügen. Markieren musst du dieses Textfeld übrigens nicht....auch Send("key") ist eher suboptimal, das hast du selbst schon festgestellt!

  • Hexacode einer Zugangskarte in eine Dezimalzahl umwandeln

    • Andy
    • 13. Juli 2016 um 19:02

    Und Oliver sollte mal seine Hausaufgaben machen....
    Ich hab auf den Link dieses USB-Readers geklickt, mir die Seite durchgelesen und bin nach einigen Sekunden darüber gestolpert:

    Code
    Dieser Code kann mit unserem Umrechnungsprogramm als Dezimalcode dargestellt oder als Passwortschutz in eigenen Programmen genutzt werden.
    Excel Umrechnungsprogramm HEXA hier downloaden.

    Es gibt also bereits eine komplette Anwendung zur Übertragung der Hexcodes in viele weitere Formate. Excel-Sheet runterladen, fertig. Da mache ich mir nicht mal die Mühe über die Programmierung einer eigenen Anwendung nachzudenken.

  • "Alte Kiste" als 24/7 Server?

    • Andy
    • 10. Juli 2016 um 20:57
    Zitat von alpines

    es gibt auch PCs die ziehen nur 30W.

    Dann ist die Annahme schon völlig verkehrt..., denn

    Zitat von alpines

    Der Server muss ja nicht zwangweise 24/7 laufen,

    heißt ja nichts anderes, als dass die Steam-Downloads nicht "lange" dauern, also eine "schnelle" Leitung zur Verfügung steht, welche aber nicht vorhanden ist...
    Wer einen Server hat mit dem Hintergrund, dass dieser 24/7 downloaden soll (oder wenigstens ständig nach Updates sucht) und diesen keine 24/7 laufen lässt, hat irgendetwas vom Konzept nicht verstanden.

    Wer keinen 24/7 Server braucht, der kann seinen Arbeits/Spiele-Rechner morgens/abends kurz aus dem Standby holen, evtl. stundenlang Downloads laden und danach legt sich der Rechner wieder schlafen. Dann ist ein "Server" extra für diese Tätigkeit völlig überflüssig...


    Zitat von Lottich

    Kann man eine alte Gurke, die quasi kaum Strom verbraucht

    "wenig Strom verbraucht" ist genau der Punkt auf den es ankommt...

  • "Alte Kiste" als 24/7 Server?

    • Andy
    • 10. Juli 2016 um 20:28

    Hi,
    ein Jahr hat 8760h, der Preis für die kWh Strom beträgt zzt. irgendetwas um 0,25€.
    Der Preis für die Stromkosten sind also 0,25€/kWh*8760h/Jahr * Leistung[kW] also 2190€/kW/Jahr*Leistung[kW].
    Mal angenommen, der "alte" Rechner verbraucht wirklich 100W, dann wären das 219€/Jahr....nur für "Download von Steam-Updates". In 5 Jahren knapp 1100 Euros...nur für die Stromkosten.
    Da ist es wirtschaftlich ( ökonomisch ist das sowieso nicht... ) günstiger, einen der "neuen" supersparsamen Server zu kaufen, welcher nur ca. 10W "schluckt".
    http://www.heise.de/ct/ausgabe/201…on-2159391.html
    Der kostet 200€, Festplatte und ggf. RAM aus dem "alten" Rechner sollte man wiederverwenden können.
    In 5 Jahren kostet dieses Modell mit angenommen 10W also 2190€/kW*0,01kW * 5Jahr= 110 €. Plus die ca. 200€ für den Rechner knapp 300€...das eingesparte Geld sollte man verfressen, versaufen, verhu*** oder in den Urlaub fahren, aber sicher nicht dem Stromanbieter hinterherwerfen!

    Krass gesagt, kauf einen neuen sparsamen Server und alle Steam-Spiele in den nächsten Jahren hast du kostenlos dabei!

  • Seltsames Leuchten in den Wolken

    • Andy
    • 10. Juli 2016 um 07:01

    Ich bleib dabei...https://de.wikipedia.org/wiki/Himmelsstrahler
    Gibt´s auch rotierend,

    Zitat von Mars

    Wenn es ein Strahler gewesen ist müsste ein stroboskopeffekt mit eingebaut gewesen sein, die Wölkchen wurden nicht "von links nach rechts" hell (wie wenn man einen beweglichen Strahler draufhält), sondern an jeder Stelle exakt zur gleichen Zeit.

    und vor allem als "Bündel", welches viele Strahlen gleichzeitig in den Himmel richtet!

  • Seltsames Leuchten in den Wolken

    • Andy
    • 9. Juli 2016 um 13:32

    Gibt´s in der Umgebung von ca. 20-30km oder noch weiter entfernt eine Disco? Nicht lachen, GENAU das von dir beschriebene Phänomen haben ein Freund und ich auf der Heimfahrt spätnachts vor einigen Jahren aus dem Auto beobachten können. Auf dem "flachen Land" (Odenwald) war es sackdunkel, die "Wölkchen" unauffällig, plötzlich fingen einzelne Wölkchen an zu leuchten. Ursache (ja, nach einigen Stunden rumgefahre durch die "Wildnis") war einer dieser transportablen "Megastrahler" vor einer Disco, der den Lichtstrahl über den Himmel rotieren ließ....normalerweise ballern die in eine Wolkendecke und sind somit "punktuell" je nach Wolkenhöhe kilometerweit sichtbar.
    Wenn aber, infolge Hochnebel oder "Schleierwölkchen" nix richtiges da ist, um den Lichtstrahl zu projizieren, dann wird der scharfe Strahl aufgefächert, und erleuchtet dann weit darüberstehende Wolken nicht mehr "scharf", sondern diffus.

  • Hilfe bei Array !

    • Andy
    • 8. Juli 2016 um 23:57

    Ich habe keine Ahnung, wie du bei dieser Problematik auf die Verwendung eines Arrays kommst, wenn du doch letztendlich einen String haben willst....
    Du erstellst ein Array, beschreibst die Array-Items mit Strings, durchsuchst die Array-Items nach Strings, löschst diese Array-Items und schreibst letztendlich alle übriggebliebenen Arrayitems in einen String. Viel komplizierter geht es garnicht....von einer Funktion mit 21 Parametern ganz zu schweigen... :Face:

    AutoIt
    #include <Array.au3>
    ;~ # Prüfen ob alle checkboxen ausgefüllt wurden
    
    
    
    
    Local $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21
    
    
    $vorher = ""
    ;Variablen füllen und als string ausgeben
    For $i = 1 To 21
        Assign($i, Random(0, 1, 1) = 1 ? "OK" : "Fehler")
        $vorher &= $i & "  " & Eval($i) & @CRLF
    Next
    ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $vorher = ' & $vorher & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    MsgBox(262144, 'Debug line ~' & @ScriptLineNumber, 'Selection:' & @CRLF & '$vorher' & @CRLF & @CRLF & 'Return:' & @CRLF & $vorher) ;### Debug MSGBOX
    
    
    
    
    ;die "komplizierte Lösung"
    $nachher1 = _check21($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
    MsgBox(262144, 'Debug line ~' & @ScriptLineNumber, 'Selection:' & @CRLF & '$nachher1' & @CRLF & @CRLF & 'Return:' & @CRLF & $nachher1) ;### Debug MSGBOX
    
    
    ;so geht das als Einzeiler, ohne Funktion
    $nachher2=stringregexpreplace($vorher,"(?m)(^\d+  OK\s+)","")
    MsgBox(262144, 'Debug line ~' & @ScriptLineNumber, 'Selection:' & @CRLF & '$nachher2' & @CRLF & @CRLF & 'Return:' & @CRLF & $nachher2) ;### Debug MSGBOX
    
    
    
    
    
    
    
    
    Func _check21($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
    
    
        $nachher = ""
        For $i = 1 To 21
            If StringInStr(Eval($i), "Fehler") Then $nachher &= $i & "  Fehler" & @CRLF
        Next
        Return $nachher
    EndFunc                                                                                                       ;==>_check21
    Alles anzeigen
  • Wie verlässlich ist der _Crypt_FileHash Befehl

    • Andy
    • 7. Juli 2016 um 18:23
    Zitat von BOfH73

    Wie groß ist die Wahrscheinlichkeit dass so ein Fall auftritt? Wie verlässlich ist die Hashwert-Ermittlung mit _Crypt_Hashfile?

    Hat jemand da Erfahrungen?

    Ja, hunderttausende Dateien "gehashed" und "logischerweise" kam keiner der 16 Byte langen Hashcodes doppelt vor.
    Das ist auch klar, wenn man weiß, wie die Erstellung eines Hash funktioniert. Ändert man an den Daten auch nur ein einziges Bit, dann wird der Hash völlig anders sein!
    Und bei 128 Bit (das sind dezimal 18446744073709551616, also 18e18 unterschiedliche Hashes) bleiben statistisch nicht viele Möglichkeiten für einen doppelten Hash bei einigen hunderttausend Dateien :D . Aber wie das bei Statistik so ist, nichts ist unmöglich! Also mach das, was AspirinJunkie vorgeschlagen hat, und prüfe die beiden Dateien mit "angeblich" gleichem Hash!

  • Datei gegen Zugriff von anderer Seite sperren

    • Andy
    • 7. Juli 2016 um 06:36

    Du könntest auch einfach ein Fileattribut setzen, welche(s) ist erstmal egal. https://autoit.de/onlinehilfe/functions/FileSetAttrib.htm
    Die Programme dürfen nur auf die Datei zugreifen, wenn das "Hidden"-Flag nicht gesetzt ist.
    Ist das "Hidden"-Flag gesetzt, wird vom ersten Programm, welches diesen Zustand bemerkt, das Hidden-Flag gesetzt ("Leseschutz eingeschaltet") und die Datei gelesen. Danach wird das Flag wieder zurückgesetzt.

  • Prog übergibt Parameter an seine 1 Instanz (mehrere Dateien via Kontext-Menü)

    • Andy
    • 7. Juli 2016 um 06:04

    Hi!
    Wenn man weiß, nach was man suchen muss (sendto), ist alles hganz einfach :D
    Aktion auf markierte Dateien anwenden

  • Forum Problemsammlung

    • Andy
    • 7. Juli 2016 um 05:58
    Zitat von Code-Jack

    Inzwischen fand ich die Ursache für dieses Problem:
    Und zwar habe ich meinen Firefox aus Sicherheitsgründen so konfiguriert, dass er Websites das Nachladen von Fonts aus dem Internet verbietet und statt dessen ausschließlich die lokal bei mir installierten Fonts verwendet.

    Erstmal klasse, dass du die Lösung gesucht, gefunden, und hier gepostet hast! :thumbup:
    Bei genauem hinsehen auf deinem Screenshot sieht man sogar den "Ersatzfont" (sieht mir ähnlich aus wie ein bspw. Unicode-Index), hätte man also schon sehr viel früher "sehen" :D können...

  • FileWrite funktioniert nicht so wie es soll

    • Andy
    • 6. Juli 2016 um 19:23

    Rumgeeiere wieder mal... :Face:

    Textdatei in Scite öffnen, im Reiter "Ansicht" jeweils den Haken bei "Leerzeichen" und "Zeilenende" setzen, Screenshot machen, posten, Problem erledigt...
    Alternativ die Textdatei im Hexeditor öffnen, Screenshot posten, Problem ebenfalls erledigt...

    Wieso dann das Problem erledigt ist?!
    Weil der TE dann sofort sieht, ob jetzt das Lesen oder das Schreiben der Datei das "Problem" ist! Ich frage mich, wieso dazu ein Thread eröffnet werden muss.

    Allein beim Titel "Filewrite funktioniert nicht so wie es soll" kommt mir ehrlich gesagt die Galle hoch!
    Wenn das so wäre, dann hätte die gesamte AutoIt-community seit 10 Jahren ein wirklich ernsthaftes Problem. Filewrite() funktioniert einwandfrei, soviel steht fest! Genauso wie alle anderen File/Write/Read-Funktionen.

    Zitat von Lanealine

    das problem liegt darin, wenn ich die zahlen aus der von autoit geschriebenen .txt rauskopiere, sieht das ganze so aus:

    Der größte Mist ever! Beim "rauskopieren" sieht man definitiv GARNICHTS, den Text sieht man nur, wenn man etwas irgendwo anders REINKOPIERT! Und wo hat der TE reinkopiert? Eben, 6, setzen....
    Wenn nämlich das verwendete Programm CR und LF als Einzelzeichen interpretiert (und das ist in einigen Teilen der Welt standard!), dann ist die dargestellte Textanzeige nämlich völlig normal...

    Jetzt reg ich mich wieder ab...btw. wieder einer auf der Ignore-List!

  • TCPRecv liefert komische Zeichen

    • Andy
    • 5. Juli 2016 um 13:20
    Zitat von Maxoo

    Mit TCPRecv empfange ich nur kryptische Zeichen wie diese hier: ÿýÿý ÿý#ÿý'ÿý$.

    Naja, was steht denn zur Rückgabe von TCPRecv in der Hilfe...nicht bemühen, ich habs schon...

    Zitat von AutoIt-Hilfe zu TCPRecv

    Return Value

    Success: the binary/string sent by the connected socket.

    und aus der deutschen Hilfe

    Zitat von deutsche Hilfe zu TCPRecv

    Rückgabewert

    Erfolg: Gibt, gesendet vom verbundenen "Socket", binär oder String zurück.
  • Reguläre Ausdruck. Komme nicht weiter

    • Andy
    • 5. Juli 2016 um 13:13
    Zitat von Rici64

    Habt Ihr da ein spezielles Programm?

    ja, bei komplizierteren RegEx benutze ich das gerne -> https://regex101.com
    Die Erklärungen helfen weiter und auch das Registerzur Anzeige der Tokens ist hilfreich...ich bin schließlich schon alt, da muss man nicht mehr alles im Kopf haben..
    "Wissen ist wissen, wo es steht!"

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™