Dieses Tutorial setzt , die in
besprochenen Befehle/Funktionen vorraus .
Ihr könnt euch dieses Tutorial und viele andere auch herunterladen und somit auch offline betrachten :
-------------------------------------------------------------------------------------------------
Kapitel V : Weitere Schleifen und Bedingungs-Blöcke
Kapitel VI : AdlibEnable , AdlibDisable
(In der neusten Version heißen die Befehle AdlibRegister und AdlibUnRegister)
Kapitel VII : Datenverwaltung
Kapitel IIX : ShellExecute
Kapitel IX : Funktionen und Includes
Kapitel X : Arrays
Kapitel XI : Pixel
Kapitel XII : Internet Explorer Automation
-------------------------------------------------------------------------------------------------
Kapitel V : Weitere Schleifen und Bedingungs-Blöcke
Teil 1 : Nützliche Schleife (For-Schleife)
Zuerst schauen wir uns dieses kleine Skript genauer an :
PHP Code:
For $i=24 To 30 Step 2
MsgBox(0,"Variable","Die Variable $i hat den Wert "&$i)
Next
Das heißt im Grunde nur , dass die Variable $i den Wert 24 erhält , anschließend wird von 24 in zweier Schritten
hochgezählt bis 30 .
Next ist das Ende der Schleife .
Nachdem $i den Wert 30 erhalten hat , läuft das Skript ganz normal weiter .
Man könnte das ganze auch so schreiben :
PHP Code:
$i=24
Do
MsgBox(0,"Variable","Die Variable $i hat den Wert "&$i)
$i=$i+2
Until $i = 30
-------------------------------------------------------------------------------------------------
Kapitel V : Weitere Schleifen und Bedingungs-Blöcke
Teil 2 : Nützlicher Bedingungs-Block (Switch)
PHP Code:
$input = InputBox("Hallo","Gib eine Zahl zwischen 1 und 30 ein")
Switch $input
Case 1 To 11
MsgBox(0,"Info","Die Zahl war zwischen 1 und 11")
Case 12 To 17
MsgBox(0,"Info","Die Zahl war zwischen 12 und 17")
Case 18 To 30
MsgBox(0,"Info","Die Zahl war zwischen 18 und 30")
Case Else
MsgBox(0,"Info","Die Zahl ist größer als 30 oder das Eingegebene war keine Ziffer")
EndSwitch
PHP Code:
$input = InputBox("Hallo","Gib eine Zahl zwischen 1 und 30 ein")
InputBox("Hallo","Gib eine Zahl zwischen 1 und 30 ein") mit diesem Befehl wird eine Inputbox erstellt (sollte bereits bekannt sein)
Switch $input ist der Anfang der Switch Bedingung .
Case 1 To 11 , dieser Abschnitt überprüft jetzt ob die Variable $input gleich irgendeiner Zahl zwischen 1 und 11 ist
wenn das eine wahre Aussage ist , dann wird eine MsgBox gezeigt .
Case 12 To 17 das selbe wie Case 1 To 11 nur diesesmal wird überprüft , ob $Input größer gleich 12 und kleinergleich 17 ist .
Case 18 To 30 das selbe wie Case 1 To 11 nur diesesmal wird überprüft , ob $Input größer gleich 18 und kleinergleich 30 ist .
Case Else wenn die Variable keine Zahl zwischen 1 und 30 ist , dann wird Case Else ausgeführt .
Case Else ist es im Vergleich zu Case 1 To 11 egal was für einen Wert die Variable hat .
Es ist nur wichtig , dass kein Case-Statement mit dem Wert der Variablen zusammenpasst .
EndSwitch das ist das Ende des Switch-Blockes , das Skript läuft danach normal weiter .
-------------------------------------------------------------------------------------------------
Kapitel VI : AdlibEnable , AdlibDisable
Teil 1 : AdlibEnable
Kurze Befehlserläuterung :
(In der neusten Version heißt der Befehl AdlibRegister , die Werte zwischen den Klammern sind aber die selben wie beschrieben)
Aufbau von AdlibEnable :
PHP Code:
AdlibEnable(Auszuführende Funktion in Anführungszeichen ohne Klammern,Zeit in msek)
PHP Code:
AdlibEnable("Test",4000)
While 1
sleep(200)
WEnd
Func Test()
MsgBox(0,"Hallo","Schon wieder sind 4 Sekunden rum")
EndFunc
Das Skript läuft ganz normal weiter , sobald aber 4 Sekunden rum sind , wird das Skript gestoppt
und erst nachdem die Funktion , die angegeben wurde , ausgeführt wurde (in unserem Falle die Funktion Test() ) ,
geht das Skript genau da weiter , wo es aufgehört hat , deswegen sollte man auch die Zeit , wann die Funktion
immer ausgeführt werden soll nicht zu niedrig setzen , denn sonst kann es passiern , dass das Hauptskript garnicht
mehr weiterläuft und andauernd gestoppt wird .
Die While Schleife im Skript , brauchen wir , da sich sonst das Skript beenden würde .
Kurze Wiederholung zu Funktionen :
Eine Funktion ist sozusagen eine Sammlung von Befehlen , die man überall im Skript mit nur einem Befehl , dem Funktionsnamen , aufrufen kann .
-------------------------------------------------------------------------------------------------
Kapitel VI : AdlibEnable , AdlibDisable
Teil 2 : AdlibDisable
Aufbau von AdlibDisable :
(In der neusten Version heißt der Befehl AdlibUnRegister , die Werte zwischen den Klammern sind aber die selben wie beschrieben)
PHP Code:
AdlibDisable()
PHP Code:
AdlibEnable("Test",4000)
For $i = 0 To 10 Step 1
sleep(1000)
Next
AdlibDisable()
MsgBox(0,"Hallo","Wir sind an der While Schleife angelangt")
While 1
sleep(200)
WEnd
Func Test()
MsgBox(0,"Hallo","Schon wieder sind 4 Sekunden rum")
EndFunc
Die While Schleife wurde nur eingebaut , damit man sieht , dass die Funktion
Test() nicht weiter ausgeführt wird .
-------------------------------------------------------------------------------------------------
Kapitel VII : Datenverwaltung
Dieses Kapitel ist um einiges umfangreicher als die Anderen .
Ich werde versuchen auf möglichst viel einzugehen , aber Ich kann
nicht jeden Befehl einzeln erklären , das würde einfach viel zu
umfangreich werden .
Bevor es los geht will ich euch kurz erklären was Ini-Dateien sind .
Im Grunde sind Ini-Dateien nichts anderes als Text-Dateien , nur mit dem einem Vorteil ,dass man gezielt Werte von einer Ini-Datei auslesen lassen kann .
Das wäre zum Beispiel ein logischer Aufbau einer Ini-Datei :
Code:
[Name] <--Das ist die Sektion name1=Max Mustermann <--Das ist eine Untersektion , auch Key(Schlüssel) genannt name2=Gabriele Mustermann [Straße] straße1=Musterstraße straße2=Musterstraße
dass es sich so leicht nachvollziehen lässt.
-------------------------------------------------------------------------------------------------
Kapitel VII : Datenverwaltung
Teil 1 : Ini-Dateien
PHP Code:
IniWrite("Test.ini","Sektion1","Wert1_in_Sektion1","13")
IniWrite("Test.ini","Sektion1","Wert2_in_Sektion1","100")
IniWrite("Test.ini","Sektion2","Wert1_in_Sektion2","5")
$read=IniRead("Test.ini","Sektion1","Wert1_in_Sektion1","")
MsgBox(0,"Info",$read)
IniDelete ("Test.ini")
Der Befehl IniWrite , schreibt einen Text an einer ganz bestimmten Stelle in die
Ini-Datei .
IniWrite("Test.ini","Sektion1","Wert1_in_Sektion1" ,"13") :
Erster Wert , den wir haben ist Test.ini .
Test.ini , ist die Ini-Datei in welcher geschrieben werden soll , wenn keine Ini-Datei mit
dem Namen vorhanden ist , wird sie einfach erstellt .
Der zweite Wert ist Sektion1 .
Dieser Teil des Befehls , sagt in welche Sektion , der Text kopiert werden soll .
Eine Sektion ist sozusagen ein Überordner für die Unter-Sektionen .
Wenn diese Sektion nicht vorhanden ist , wird sie vom Programm erstellt .
Eine Sektion dient dazu , dass man die Werte besser zuordnen kann und
Ordnung in die Datenstruktur bringt.
Der dritte Wert ist Wert1_in_Sektion1 .
Dieser Wert , teilt dem Computer mit , in welchen Unter-Sektion der Text geschrieben werden soll .
Wenn keine passende Unter-Sektion vorhanden ist , wird eine erstellt .
Der letzte Wert , 13 , ist der Text , der in die Untersektion geschrieben werden soll .
Man kann den Aufbau eines IniWrite-Befehls mit einem Ordner vergleichen :
Der erste Wert (in unserem Falle Test.ini) , des IniWrites-Befehls wäre dann also der Überordner .
Der zweite Wert (in unserem Falle Sektion1), wäre ein Unterordner im Überordner .
Der dritte Wert (in unserem Falle Wert1_in_Sektion1), wäre dann wieder ein Unterordner im Unterordner
und erst der letzte Wert (in unserem Falle 13), wäre dann das Programm , nachdem man gesucht hat .
Weiter gehts mit dem Skript :
IniWrite("Test.ini","Sektion1","Wert2_in_Sektion1" ,"100")
Dieser IniWrite-Befehl , schreibt also in der Test.ini Datei , in die Sektion1 ,
in die Untersektion Wert2_in_Sektion1 , den Text 100 .
Nächster Befehl :
IniWrite("Test.ini","Sektion2","Wert1_in_Sektion2" ,"5")
Dieser IniWrite-Befehl , schreibt also in der Test.ini Datei , in die Sektion2 ,
in die Untersektion Wert1_in_Sektion2 , den Text 5 .
IniRead , liest aus einer Ini-Datei einen text aus .
$read=IniRead("Test.ini","Sektion1","Wert1_in_Sekt ion1","")
Der Variable $read wird der Text, des ausgelesenen (vergleichbar mit $input=InputBox(........) )
Abschnittes , zugewiesen .
Der erste Wert , den wir in unserem Befehl haben , ist mal wieder , wie immer ,
die Datei aus der etwas ausgelesen werden soll ( Test.ini )
Der zweite Wert (Sektion1) ist die Übersektion , aus der etwas ausgelesen werden soll .
Der dritte Wert (Wert1_in_Sektion1) ist die Untersektion (Wert1_in_Sektion1) in der Übersektion (Sektion1)
, aus der etwas ausgelesen werden soll .
Der letzte Wert in dem IniRead-Befehl ist der Text , den die Variable $read erhalten soll ,
wenn das Auslesen scheitert (z.b. wegen nicht Vorhanden sein der Ini-Datei oder
wegen nicht Vorhanden sein der Übersektion) .
IniDelete("Test.ini") , löscht die Ini-Datei Test.ini .
Beispielcode zur Verwendung von Ini-Dateien :
PHP Code:
$read1=IniRead("Daten.ini","Namen","Vorname","")
$input1=InputBox("Gib deinen Namen ein","Gib deinen Vornamen ein",$read1)
IniWrite("Daten.ini","Namen","Vorname",$input1)
$read2=IniRead("Daten.ini","Namen","Nachname","")
$input2=InputBox("Gib deinen Namen ein","Gib deinen Nachnamen ein",$read2)
IniWrite("Daten.ini","Namen","Nachname",$input2)
$read3=IniRead("Daten.ini","Namen","Spitzname","")
$input3=InputBox("Gib deinen Namen ein","Gib deinen Spitznamen ein",$read3)
IniWrite("Daten.ini","Namen","Spitzname",$input3)
Schreiberleichterung des Benutzers (einmaliges Eingeben reicht , wenn die Ini-Datei nicht
gelöscht wird ) und wenn man jetzt nicht 3 Inputboxen hat sondern 40 dann hat warscheinlich keiner Lust jedesmal beim Programmstart das selbe wie bereits eingegeben wurde nochmal einzugeben .
-------------------------------------------------------------------------------------------------
Kapitel VII : Datenverwaltung
Teil 2 : Dateien Allgemein
PHP Code:
#Include <File.au3>
_FileCreate("Test.txt")
$file=FileOpen("Test.txt",1)
FileWrite("Test.txt","Das hier wird in die Datei geschrieben")
FileClose($file)
#Include <File.au3>
Was das bringt , wird im nächsten Kapitel erklärt .
_FileCreate("Test.txt") , dieser Befehl erstellt eine Datei , in unserem Beispiel erstellt er
eine Text-Datei mit dem Namen Test .
Man kann mit diesem Befehl aber auch genau so gut .bat .exe usw. Dateien erstellen lassen .
Bsp :
_FileCreate("Test.bat")
$file=FileOpen("Test.txt",1)
Die Variable $file brauchen wir für später , damit unser Programm weiß ,welche
Datei es schließen soll .
FileWrite("Test.txt","Das hier wird in die Datei geschrieben")
Der erste Wert , ist die Datei , in welche ein Text geschrieben werden soll .
Der zweite Wert , ist der Text , der in die Datei geschrieben werden soll
FileClose($file), nachdem wir die Datei geöffnet haben , sollte sie auch wieder geschlossen werden ,
damit sich der Pc nicht nach 10.000 offenen Text-Dateien aufhängt .
-------------------------------------------------------------------------------------------------
Kapitel VII : Datenverwaltung
Teil 3 : Dateien Allgemein
PHP Code:
#Include <File.au3>
if FileExists("Test.txt")=0 Then
_FileCreate("Test.txt")
EndIf
FileMove ("Test.txt","Test.au3")
, für was er gebraucht wird , wird im nächsten Kapitel besprochen .
if FileExists("Test.txt")=0 Then , wenn die Datei , Test.txt bereits existiert und wenn sie in dem selben Ordner wie das Skript ist , dann wird der Bedingungsblock übersprungen .
FileMove ("Test.txt","Test.au3"), dieser Befehl nennt die Datei Test.txt in Test.au3 um .
-------------------------------------------------------------------------------------------------
Kapitel IIX : ShellExecute
Teil 1 : ShellExecute
Mit ShellExecute , kann man Dateien ausführen,öffnen,bearbeiten und vieles mehr .
Ein paar Beispiele :
Nummer 1 :
PHP Code:
ShellExecute("myfile.txt", "", @ScriptDir, "edit")
Der nächste Wert , "" ist der Parameter , der dem Programm übergeben werden soll , in unserem Beispiel übergeben wir nichts , da wir nichts übergeben müssen
Der nächste Wert ist der Ordner in dem die Datei liegt .
@ScriptDir ist ein Macro , es ist ein festgelegter Wert , den man selbst nicht ohne weiteres verändern kann . @ScriptDir , ist der Pfad zum Ordner , wo die AutoIt Datei ist , in welcher das Macro ausgeführt wurde .
edit , ist ein Wert , der festlegt was mit der Datei passieren soll , in unserem Falle soll die Datei mit ihrem Standarteditor geöffnet werden .
Nummer 2:
PHP Code:
ShellExecute("test.exe")
Nummer 3:
PHP Code:
ShellExecute("http://www.elitepvpers.com/forum/")
Nummer 4:
PHP Code:
ShellExecute("myfile.txt", "", @ScriptDir, "print")
Nummer 5 :
PHP Code:
ShellExecute("myfile.lnk", "", @ScriptDir, "properties")
-------------------------------------------------------------------------------------------------
Kapitel IX : Funktionen und Includes
Teil 1 : Funktionen
PHP Code:
test()
For $i=0 to 2 Step 1
sleep(500)
MsgBox(0,"Hallo","Die Funktion test() wird momentan nicht ausgeführt")
Next
AndereFunktion()
Func test()
MsgBox(0,"Hallo","Die Funktion test() wird ausgeführt")
EndFunc
Func AndereFunktion()
MsgBox(0,"Hallo","Die Funktion AndereFunktion() wird ausgeführt")
EndFunc
, den wir erstellt haben .
Immer wenn jetzt irgendwo im Skript der Name der Funktion (in unserem Falle test() ) auftaucht ,
dann wird alles was in der Funktion (zwischen Func test() und zwischen EndFunc ) ist , ausgeführt .
Also wenn wir irgendwo im Skript die Funktion test() aufrufen , dann wird jedesmal das ausgeführt :
MsgBox(0,"Hallo","Die Funktion test() wird ausgeführt") .
Soweit sollte bisher alles bekannt sein .
Jetzt kommen wir zum Neuen :
PHP Code:
TestFunktion("Hi","Hallo")
sleep(1000)
TestFunktion("Guten Morgen","Du da")
Func TestFunktion($text,$text2)
MsgBox(0,"Hallo","Die Variable $text hat den Wert :"&$text)
MsgBox(0,"Hallo","Die Variable $text2 hat den Wert :"&$text2)
EndFunc
Der einzige Unterschied zu den Standartbefehlen in AutoIT ist , dass der Text vor den Klammern nicht farbig ist ,
das ist aber auch wirklich der einzige .
$text ist der erste Wert , alles was du jetzt nachdem du die Funktion TestFunktion aufgerufen hast , in die Klammern schreibst
wird in einer Variablen gespeichert .
Also wenn du z.b. das schreibst :
TestFunktion("Test","Test2")
wird in der Variable $text der Text Test gespeichert und in der Varibale $text2 wird dann folgendes gespeichert :
Test2
Man könnte das ganze obere Skript auch so schreiben :
PHP Code:
$text="Hi"
$text2="Hallo"
MsgBox(0,"Hallo","Die Variable $text hat den Wert :"&$text)
MsgBox(0,"Hallo","Die Variable $text2 hat den Wert :"&$text2)
sleep(1000)
$text="Guten Morgen"
$text2="Du da"
MsgBox(0,"Hallo","Die Variable $text hat den Wert :"&$text)
MsgBox(0,"Hallo","Die Variable $text2 hat den Wert :"&$text2)
Wenn das Skript jetzt noch länger wäre , hätte keiner mehr einen Überblick und wegen den ganzen verschiedenen Variablen
würde es ewig dauern bis man einen Fehler gefunden hat .
Aber Funktionen haben noch einen Vorteil , man kann Standartwerte für die Variablen setzen , wenn der
Variable kein Wert zugewiesen wird :
PHP Code:
lol()
sleep(1000)
lol("test")
Func lol($text = "hallo")
msgbox(0,"hallo",$text)
EndFunc
wird der Standarttext genommen .
Beim zweitenmal Aufrufen der Funktion lol() wird der Text : test in der Varibalen $text gespeichert und ersetzt somit den Standarttext .
Wenn wir jetzt wieder die Funktion lol() ohne Wert aufrufen würden , dann würde wieder der Standarttext (in unserem Falle hallo) erscheinen und nicht der Text
, den wir zuletzt gespeichert haben .
-------------------------------------------------------------------------------------------------
Kapitel IX : Funktionen und Includes
Teil 2 : Includes
PHP Code:
#include <IE.au3>
_IECreate ("www.google.de")
_IECreate ("www.google.de")
Dieser Befehl würde den Internetexplorer starten und als momentane Seite www.google.de anzeigen .
Und jetzt zu den #include <IE.au3> :
Der Befehl #include<Dateiname.au3> , importiert die Befehle der zu importierenden Datei und
setzt diese sozusagen an den Anfang des Skriptes .
Wie wir oben bereits festgestellt haben , kann man sich Befehle selbst erstellen ,
diese Dateien , die importiert werden sind im Grunde nichts anderes wie Funktionen , die von jemand anderem gemacht wurden .
Damit haben sie euch sozusagen die Arbeit abgenommen .
Diese Dateien , nennt man auch UDF (User Defined Function , deutsch : Benutzer definierte Funktion) .
Alle Befehle mit einem _ vorne , benötigen eine Include Datei , welche das ist kann man in der Help Datei nachsehen .
Ganz oben im gelben Kästchen steht immer der Befehlsaufbau und die zu importierende Datei .
Wenn wir uns mal die IE.au3 Datei näher anschauen , werden wir etwas finden was uns bekannt vorkomme sollte :
PHP Code:
Func _IECreate($s_Url = "about:blank", $f_tryAttach = 0, $f_visible = 1, $f_wait = 1, $f_takeFocus = 1)
blablabla
EndFunc
-------------------------------------------------------------------------------------------------
Kapitel IX : Funktionen und Includes
Teil 3 : Return
PHP Code:
$ergebnis=Addiere(2,3)
MsgBox(0,"Ergebnis","$a + $b addiert ergibt : "&$ergebnis)
Func Addiere($a,$b)
Return $a+$b
EndFunc
$ergebnis=Addiere(2,3) , in der Variable $ergebnis wird das , was von der Funktion Addiere(2,3) hinter Return steht , gespeichert .
Return braucht man besonders , wenn man größere Projekte hat und bei jeder Funktion ein Return einbaut , damit man weiß ob alles
richtig abgelaufen ist oder ob ein Fehler aufgetreten ist .
Man kann das ganze mit den original Befehlen von AutoIT vergleichen Beispielweise : $input=InputBox(...) .
Beispiel :
PHP Code:
$zahl1=InputBox("Dividieren","Gib eine Zahl ein die geteil werden soll")
$zahl2=InputBox("Dividieren","Gib die Zahl ein , die die andere Zahl teilt")
$ergebnis=Teile($zahl1,$zahl2)
MsgBox(0,"Ergebnis","$a/$b ergibt : "&$ergebnis)
Func Teile($a,$b)
If $b=0 Then
Return "Durch 0 darf nicht geteilt werden "
Else
Return $a/$b
EndIf
EndFunc
Kapitel X : Arrays
Teil 1 : Arrays allgemein
Ich fange immer recht gerne mit einem Beispiel an , da sich alles dann leichter erklären lässt :
PHP Code:
Dim $variable[50]
$variable[0]="hi"
$variable[1]=" "
$variable[2]="du"
MsgBox(0,"Test",$variable[0]&$variable[1]&$variable[2])
trotzdem habe ich diesen Code als Beispiel genommen , denn umso leichter der Code ist , desto leichter lässt sich ein Befehl erklären .
Damit der Pc weiß , was ein Array ist braucht man einen Befehl dafür , in unserem Fall ist es der hier : Dim $variable[50] .
Aber was ist ein Array ? :
Code:
Ein Array ist ein Datentyp, in dem beliebig viele Werte abgespeichert werden können. Während eine Variable eines elementaren Datentyps immer nur einen einzelnen Wert enthält, kann eine Arrayvariable eine größere Anzahl verschiedenster Werte enthalten. Das Verhältnis zwischen einer Variablen und einem Array entspricht in etwa dem Verhältnis zwischen einem Segelboot und einem Ozeandampfer oder einem Fahrrad und einem Bus. Eine Variable ist wie ein Segelboot, das lediglich einer Person Platz bietet. Die Person stellt dabei den Variablenwert dar. Ebenso wie der Wert einer Variablen wechseln kann, kann auch ein Segelboot im Laufe der Zeit von unterschiedlichen Personen verwendet werden. Wenn Sie nun wissen wollen, wem das Segelboot gehört, müssen Sie wissen, wie Sie zu diesem Segelboot gelangen. Zu diesem Zweck hat jedes Segelboot einen Heimathafen, ebenso wie jede Variable einen Variablennamen hat, über den Sie auf die Variable zugreifen. Wenn Sie ein Array verwenden, führt Sie der Arrayname lediglich zu dem Array, also zu einem Datenbehälter, in dem mehrere Werte abgelegt sein können. Der Name des Arrays führt Sie aber noch nicht zu einem einzelnen, in der Arraystruktur abgelegten Wert. Ebenso führt Sie der Heimathafen eines Ozeandampfers lediglich zum Ozeandampfer, aber noch nicht zu einer bestimmten, in dem Ozeandampfer befindlichen Wohneinheit. Dazu fehlt Ihnen noch die Angabe, wo im Ozeandampfer Sie die gesuchte Wohneinheit finden. Im Falle des Arrays nutzt man zur Adressierung der einzelnen Werte im Array die Tatsache, dass alle Werte im Array durchnummeriert sind, man bezeichnet dies auch als indiziert. Um auf einen bestimmten Wert im Array zuzugreifen, hängt man daher die Nummer des Werts in eckigen Klammern an den Arraynamen an. Quelle : http://selfphp.zzxl.de/praxisbuch/ps-s155-g28.html
Wir stellen uns jetzt mal vor wir haben einen Ordner , in welchem 50 Text-Dateien liegen .
Der Name des Ordners ist immer gleich , egal wieviele Dateien in ihm abgespeichert werden .
Der Ordner wäre bei uns dann die Variable $variable , also hätte unser Ordner den Namen variable .
Wir haben da jetzt eingestellt , dass wir Platz für unsere 50 Text-Dateien haben , für mehr nicht !.
Jetzt bekommen unsere Text-Dateien einen Namen , ich nummeriere sie von 0-49 durch also so in etwa :
Code:
0 1 2 3 4 . . . 49
In jeder Text-Datei ist ein anderer Text gespeichert .
Das kann man sehr gut mit Arrays vergleichen :
Dim , wäre wie beim Ordner erstellen , der Befehl "neuen Ordner erstellen" .
$variable , wäre dann der Name des Ordners .
[50] , ist die Anzahl der möglichen Dateien , die man darin speichern kann , von 0 anfangend durchnummeriert bis 49 (insgesamt 50 nummerierte Dateien) .
Um jetzt auf einen bestimmten Array zuzugreifen , muss man lediglich den Variablennamen schreiben und den Index in eckigen Klammer dahinter setzen .
$variable[3] = 1 + 2
Dem index 3 der Variable $variable wird der Wert (1+2=) 3 zugewiesen .
-------------------------------------------------------------------------------------------------
Kapitel X : Arrays
Teil 2 : Variablen als Index
Auch Variablen können in einem Array eingebaut werden :
PHP Code:
Global $name[5]
$name[0]="Hans "
$name[1]="Dieter "
$name[2]="Friedrich "
$name[3]="Manfred "
$name[4]="Thomas "
MixIt() ;Funktion MixIt wird ausgeführt
Func MixIt(); Funktion MixIt
For $a=0 To 6 Step +1
$i=Random(0,4,1)
MsgBox(0,"Name","Name : "&$name[$i])
Next
EndFunc ; Funktion MixIt ende
Local , hier dürfen die Variablen nur in der Funktion benutzt werden , in welcher sie erzeugt (deklariert) worden sind .
$i=Random(0,4,1) heißt , dass eine ganzzahlige Zahl zwischen 0 und 4 erstellt wird und in $i gespeichert wird .
$name[$i] , der Index der Variable , die angezeigt werden soll ist so groß wie der Wert von $i .
-------------------------------------------------------------------------------------------------
Kapitel X : Arrays
Teil 3 : Mehrdimensionale Arrays
PHP Code:
Dim $zahl[5][5]
$zahl[0][3]="Hi "
$zahl[3][3]="Hans "
$zahl[2][4]="Dieter "
$zahl[4][1]="Wolfgang"
MsgBox(0,"Test",$zahl[0][3]&$zahl[3][3]&$zahl[2][4]&$zahl[4][1])
(Im Anhang seht ihr ein Beispiel für Mehrdimensionale Arrays (TicTacToe) )
Der zweite Index hinter der Variable , heißt dass jede Zahl vom ersten index soviele Zahlen wie im 2.Index stehen (in unserem Fall 5) , zugewiesen bekommt .
So kann man es sich vielleicht besser vorstellen (das Minus soll eine Untersektion darstellen)
Code:
0 <-(erster Index) -0 <-(zweiter Index) -1 <-(zweiter Index) -2 <-(zweiter Index) -3 <-(zweiter Index) -4 <-(zweiter Index) 1 <-(erster Index) -0 <-(zweiter Index) -1 <-(zweiter Index) -2 <-(zweiter Index) -3 <-(zweiter Index) -4 <-(zweiter Index) 2 <-(erster Index) -0 <-(zweiter Index) -1 <-(zweiter Index) -2 <-(zweiter Index) -3 <-(zweiter Index) -4 <-(zweiter Index) 3 <-(erster Index) -0 <-(zweiter Index) -1 <-(zweiter Index) -2 <-(zweiter Index) -3 <-(zweiter Index) -4 <-(zweiter Index) 4 <-(erster Index) -0 <-(zweiter Index) -1 <-(zweiter Index) -2 <-(zweiter Index) -3 <-(zweiter Index) -4 <-(zweiter Index)
Mehrdimensionale Arrays , dienen oft zur "Herstellung" von Feldern , also z.b. bei TicTacToe gibt es ja 3*3 Felder
das lässt sich sehr schön mit einer Mehrdimensionalen Array machen nämlich so :
Dim $Felder[3][3]
Es ist aber auch möglich 3D-Felder damit zu machen , Bsp :
Dim $Felder[5][5][4] , das wäre jetzt 5*5*4=100 .
Auch das ist möglich :
Dim $Felder[5][5][4][10] , das wären dann 5*5*4*10=1000 Felder .
Soetwas braucht man aber normalerweise nicht .
Mehrdimensionale Arrays werden besonders bei der Spieleprogrammierung verwendet .
Für Hacks , Bots usw. braucht man eigentlich keine Mehrdimensionalen Arrays .
-------------------------------------------------------------------------------------------------
Kapitel XI : Pixel
Teil 1 : PixelSearch
Der Aufbau von dem Befehl PixelSearch ist folgendermaßen :
PHP Code:
PixelSearch ( left, top, right, bottom, color [, shade-variation [, step [, hwnd]]] )
left und top sind die (x1,y1) Koordinaten , der linken oberen Ecke des Rechtecks , das durchsucht werden soll und right , bottom sind die (x2,y2) Koordinaten der rechten unteren Ecke des Rechtecks , das durchsucht werden soll .
Color ist die Farbe nach der gesucht werden soll , also entweder in Dezimal Darstellung (also die Zahlen mit denen man normalerweise rechnet , 0-9)
oder man macht es per Hexadezimal Darstellung (Ich finde das besser , da man schneller einen Überblick hat , Hexdazimal : Zahlen von 0-F (F entspricht der Zahl 15 , E entspricht der Zahl 14 ,D entspricht der Zahl 13 usw.))
shade-variation bestimmt wie stark sich der Farbe eines Pixels von der gesuchten unterscheiden darf (Ich empfehle keinen Wert größer als 6 zu nehmen , da man sonst jede Menge falscher Pixel findet)
Step ist sozusagen eine Zahl , in welchen Abständen der Pixel gesucht werden soll .
Also wenn man dafür 5 eingibt , dann überprüft AutoIT nur jeden 5.Pixel , ob er die Farbe hat (bringt aber dafür große Geschwindigkeitsvorteile) .
Der letzte Wert (hwnd) ist das Fenster in dem nach dieser Farbe gesucht werden soll , wenn man z.b.
Editor eingibt , dann wird nur im Fenster Editor nach dieser Farbe gesucht , wenn man das Fenster minimiert , hört AutoIT auf zu suchen . (Ich habe noch nicht allzuviel mit hwnd rumprobiert , darum kann ich nicht viel mehr darüber sagen)
Ein Beispielcode , der auf dem ganzen Bildschirm nach jeden 2. blauem Pixel in 2 Variationen sucht und wenn eines gefunden wurde , dann wird die Koordinate des gefunden Pixels ausgegeben .
PHP Code:
$pixel=PixelSearch(0,0,@DesktopWidth,@DesktopHeight, "0x0000FF" , 1 ,2 )
If isArray($pixel) then
Msgbox(0,"Pixel gefunden","Die x Koordinate ist: "&$pixel[0]&" und die y Koordinate ist : "&$pixel[1])
EndIf
-------------------------------------------------------------------------------------------------
Kapitel XI : Pixel
Teil 2: PixelChecksum
Aufbau des Befehles PixelChecksum :
PHP Code:
PixelChecksum ( left, top, right, bottom [, step [,hwnd]] )
PixelChecksum gibt die Checksumme des Bereiches wieder , also es wird kein Punkt zurückgegeben sondern eine Zahl , die die Checksumme des Bereiches ist .
Beispielskript :
PHP Code:
$checksum = PixelChecksum(0,0, 50,50)
While $checksum = PixelChecksum(0,0, 50, 50)
Sleep(100)
WEnd
MsgBox(0, "", "Irgendetwas hat sich verändert !")
Anschliesend wird eine While Schleife ausgeführt , also solange unsere alte Checksumme genau die selbe ist wie die neue , wird immer 100 msec geschlafen (reduziert die CPU Auslastung) .
Sobald die alte Checksumme aber nicht mehr die selbe wie die neue ist , wird die MsgBox gezeigt .
-------------------------------------------------------------------------------------------------
Kapitel XII : Internetexplorer Automation
Teil 1 : Einfache Automation
PHP Code:
#include<IE.au3>
$name="Test"
$pw="1234"
$oIE=_IECreate("http://www.elitepvpers.com")
_IENavigate($oIE,"http://www.elitepvpers.com/forum")
_IELoadWait($oIE,0,30000)
$oForm = _IEFormGetCollection($oIE,1)
$oUsername = _IEFormElementGetObjByname($oForm,"vb_login_username")
$oPassword = _IEFormElementGetObjByName($oForm,"vb_login_password")
_IEFormElementSetValue ($oUsername,$name)
_IEFormElementSetValue ($oPassword,$pw)
sleep(1111)
_IEFormSubmit($oForm)
$oIE=_IECreate("http://www.elitepvpers.com") , dieser Befehl erzeugt ein Internet Explorer Fenster und der Internet Explorer wird sofort zu der angegeben Startseite naviegiert (In unserem Falle : http://www.elitepvpers.com)
_IENavigate($oIE,"http://www.elitepvpers.com/forum") , mit diesem Befehl können wir ganz bequem zu irgendwelche Internetseiten navigieren (In unserem Beispiel hätten wir den befehl nicht gebraucht , da das aber ein wichtiger Befehl ist wollte ich ihn mit einbringen).
_IELoadWait($oIE,0,30000) , es wäre natürlich unpraktisch wenn das Skript jetzt einfach weitermachen würde obwohl die Seite noch nicht fertig geladen wurde , die 0 steht für die zeit , wie lange von vorn herein gewartet werden soll (ich würde empfehlen das immer bei 0 zu lassen).
Der zweite Parameter (30000) sind die Millisekunden , bis zum Timeout (also nach 30sec , auch wenn die Seite noch nicht geladen hat , wird einfach im Skript weiter gemacht , ganz praktisch falls sich IE (Internet Explorer) beim Laden aufhängt)
$oForm = _IEFormGetCollection($oIE,1)
Mit diesem Befehl bekommt man sozusagen eine Sammlung aller Objekte , das brauchen wir sogut wie immer .
$oUsername = _IEFormElementGetObjByname($oForm,"vb_login_userna me"), jetzt sucht sich das Programm aus der Sammlung das Objekt raus , das den Namen vb_login_username hat .
Den Namen eines Objektes kann man ganz leicht (zumindest meistens) aus dem Quelltext auslesen , hier mal der Auszug vom Quelltext :
PHP Code:
<td><input type="text" class="bginput" style="font-size: 11px" name="vb_login_username" id="navbar_username"........
name="vb_login_username" , das ist der Name des Objektes .
$oPassword = _IEFormElementGetObjByName($oForm,"vb_login_passwo rd"),
das selbe wie oben nur , dass hier das Objekt mit den Namen vb_login_password rausgesucht wird .
Jetzt wo das Skript weiß , welches Objekt wir verändern wollen , können wir auch endlich dem Programm sagen , zu was es geändert werden soll und zwar mit dem Befehl :
_IEFormElementSetValue ($oUsername,$name) , dieser Befehl setzt den "Wert" , des Objektes $oUsername zu $name .
_IEFormElementSetValue ($oPassword,$pw) , dieser Befehl setzt den "Wert" , des Objektes $oPassword zu $pw .
_IEFormSubmit($oForm) , jetzt muss noch alles abgeschickt werden , am besten wir schicken die ganze Sammlung an Objekten (inklusive Änderungen) an den Server , dann können wir nichts vergessen .
Anmerkung :
Falls ihr Probleme habt ein Objekt zu finden/beschreiben solltet ihr in diesem Befehl die 1 zu einer 0 ändern :
$oForm = _IEFormGetCollection($oIE,1)
Die 1 bzw 0 legt nur fest wie die Sammlung an Objekten dargestellt werden soll .
-------------------------------------------------------------------------------------------------
Kapitel XII : Internetexplorer Automation
Teil 2 : Automation mit Hilfe von Javascript
PHP Code:
#include<IE.au3>
$oIE=_IECreate("http://www.elitepvpers.com/forum/")
_IELoadWait($oIE)
$securitytoken=$oIE.document.parentWindow.eval('javascript:SECURITYTOKEN')
Msgbox(0,"test",$securitytoken)
$oIE.document.parentWindow.eval('javascript:document.body.style.backgroundColor="#FF0000";')
sleep(1111)
$oIE.document.parentWindow.eval('document.body.contentEditable = "true"; document.designMode = "on"; void 0')
Javascript in AutoIT benutzen zu können erleichtert natürlich einiges .
Z.b. das Auslesen von Variablen , wie wir es taten .
Ohne irgendwelche Verrenkungen im Quelltext mit _StringBetween(...) und ähnlichen Sachen hätten wir das
nie so hinbekommen .
Ich werde nur kurz erklären wie man Javascript in einem AutoIT Projekt benutzen kann , da die eigentliche Schwierigkeit
meistens nicht darin besteht Javascript und AutoIT zu kombinieren , sonder eher darin , dass man javascript nicht kann .
$oIE=_IECreate("http://www.elitepvpers.com/forum/") , es wird ein
Ie Fenster erstellt mit der Seite
._IELoadWait($oIE), es wird gewartet bis der Ie fertig geladen hat .
Jetzt kommt der Interessante Teil :
$securitytoken=$oIE.document.parentWindow.eval('ja vascript:SECURITYTOKEN')
$securitytoken , ist die Variable in welcher der Rückgabewert von dem Javascript gespeichert wird .
$oIE.document.parentWindow.eval , dieser Teil ist meistens genau so wie er da steht ,
da es in AutoIT keine Klassen gibt wird es euch vielleicht verwirren , aber macht euch darüber nicht allzuviele
Gedanken , nehmt es als Fakt hin und macht den "Befehl" für javascript immer so wie oben .
('javascript:SECURITYTOKEN') , das ist der eigentliche Javascriptbefehl .
Ich denke man könnte dort auch php und Html einbauen , jedoch habe ich das noch nie zuvor probiert (müsste aber theoretisch möglich sein).
Aber zurück zum Thema , das javascript: am anfang muss bei jedem Javascriptbefehl stehen !
Die Texte/Wörter , die nach dem Doppelpunkt folgen , sind die eigentlichen Javascript-Befehle .
SECURITYTOKEN , das habe ich im Quelltext gefunden , es ist eine Javascript variable , die wie ihr seht , man
sehr leicht auslesen lassen kann , einfach den Namen der Variable und fertig (Nicht jede Sprache hat ein $ vor den Variablen
)document.body.style.backgroundColor="#FF0000"; , ändert die Hintergrund Farbe auf #FF0000 (=Rot) .
document.body.contentEditable = "true"; document.designMode = "on"; void 0 , macht die Internetseite
editierbar , was auffält ist der Strichpunkt nach dem "true" , wird der Rest des Befehl etwa auskommentiert ?
Nein nicht wirklich in javascript , java , C++ (eigentlich so ziehmlich jeder Programmiersprache) , setzt man am Ende jeder Funktion einen ; oder
etwas anderes vergleichbares , damit der Computer weiß , wann der Befehl aufhört .
Zusätzliche Erklärung (von FichteFoll)
Quote:
Das IE-Objekt hat mehrere Elemente und Unterobjekte, welche du ansteuern kannst. So gelangt man zum Beispiel über "$oIE.document.parentWindow" zum globalen Javascript-Objekt, woraufhin man jegliche Javascriptfunktion aufrufen kann und auch jede Variable ansprechen, welche ebenfalls teil des Objektes ist. "eval" ist eine Javascript-Funktion, welche explizit Javascript-Code ausführt; jedoch kann man in deinem Beispiel genauso gut
schreiben, was ebenfalls den SecurityToken zurückliefert. Ebenso kann man auchPHP Code:$securitytoken = $oIE.document.parentWindow.SECURITYTOKEN
schreiben, um die Hintergrundfarbe zu ändern. Im Übrigen wird genau dies auch in den gesamten _IE-Funktionen gemacht, nur übersichtlicher, debugreicher und allgemeiner. Allerdings kann man so keine Variablen hinzufügen.PHP Code:$oIE.document.body.style.backgroundColor = "#FF0000"
Für die Grundlagen in Javascript empfehle ich diese Seite (keine Angst AutoIT und Javascript sind sich teilweise sehr ähnlich , also denkt nicht , dass ihr jetzt wieder bei 0 Anfangen müsst)
Und für die , die es lieber deutsch haben (dieses Tutorial vermittelt wirklich nur die Grundlegensten Sachen max. 1h sollte das durchlesen und ausprobieren dauern
) :Falls ihr Browsergamebots machen wollt , solltet ihr euch das anschauen :
Für Assembler, könnt ihr hier weiter machen:
-------------------------------------------------------------------------------------------------
Das ist mein erstes Tutorial , also Leute bewertet nicht zu streng
!Ich freue mich auf Feedback !
lg Shadow992
P.S. Hier werden keine Fragen beantwortet , wenn ihr Fragen habt stellt sie mir per pm oder
erstellt
ein Thread .P.P.S. Ich weiß , dass man einiges kürzer und sauberer hätte schreiben können ,
aber da dieses Tutorial für Anfänger gedacht ist , habe ich versucht alle Skripts so einfach und übersichtlich wie möglich zu halten .
Im Anhang findet ihr ein paar opensource Skripts
Personen , die bei diesem Tutorial mitgewirkt haben :
Mankana
Das Tutorial wird immer mal ein bisschen überarbeitet und fortgeführt , also lohnt es sich einmal die Woche vorbei zu schauen .
