#NoTrayIcon
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_icon=sys\Speedwriter.ico
#AutoIt3Wrapper_outfile=Speedwriter.exe
#AutoIt3Wrapper_UseUpx=n
#AutoIt3Wrapper_Res_Description=Speedwriter
#AutoIt3Wrapper_Res_Fileversion=2.9.1.0
#AutoIt3Wrapper_Res_LegalCopyright=Oscar (www.autoit.de)
#AutoIt3Wrapper_Res_Language=1031
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#include <Crypt.au3>
#include <Date.au3>
#include <EditConstants.au3>
#include <File.au3>
#include <GUIConstantsEx.au3>
#include <Sound.au3>
#include <String.au3>

Global $GeschAnf = "00010101020202030303040404040505050505060606060606070707070707"; Geschwindigkeit: 30 Anfänger-Level
Global $GeschPro = "00030303040404050505050606060707070808080909091010101112131415"; Geschwindigkeit: 30 Profi-Level
Global $Geschwindigkeit = $GeschAnf
Global $Anz = 50; Die Anzahl der generierten Zeichen für jeden Level. Nur hier ändern, damit der Fortschrittsbalken richtig angezeigt wird.
Global $Text, $Punktzahl, $Start, $Fehler, $Schleife, $Pause, $Sp, $r1, $r2, $Name, $Schw, $P, $PT
Global $Le, $E, $Bonus, $Zeit, $ZeitStart, $ZeitUm, $PauseZeit, $Woerterbuch, $Form2, $Radio3, $Radio4
Global $Stop, $LeSt, $WoSt, $body, $RaWo

Dim $SpSt[2]
Dim $Highscore[52]; enthält = Punkte | Name | Level | Anf/Pro | Fehler | Datum
Dim $BestHighscore[52]; Highscore vom Server
Dim $HSeintrag[52]; IDs der Einträge der Bestenliste (Listviewitems)

Opt("GUIOnEventMode", 1)
Opt("TrayAutoPause", 0)
Opt("TrayMenuMode", 1)
Opt("PixelCoordMode", 0)
Opt("GUICoordMode", 1)
Opt("CaretCoordMode", 0)

;******************************************************************************************
;******************************************************************************************
$Form1 = GUICreate("Speedwriter", 789, 568, -1, -1)
GUISetOnEvent($GUI_EVENT_CLOSE, "Beenden")
GUISetIcon("sys\Speedwriter.ico")
$Tab1 = GUICtrlCreateTab(18, 72, 755, 459)

$TabSpiel = GUICtrlCreateTabItem("Spielfeld")
;******************************************************************************************
;******************************************************************************************
$SpielstaerkeGroup = GUICtrlCreateGroup("Spielstärke", 35, 118, 165, 54)
GUICtrlSetColor(-1, 0x000000)

$Radio1 = GUICtrlCreateRadio("Anfänger", 105, 131, 77, 18)
GUICtrlSetOnEvent(-1, "Radio1Click")
GUICtrlSetFont(-1, 11, 400, 0, "Times New Roman")
GUICtrlSetState(-1, $GUI_CHECKED)

$Radio2 = GUICtrlCreateRadio("Profi", 105, 150, 77, 18)
GUICtrlSetFont(-1, 11, 400, 0, "Times New Roman")
GUICtrlSetOnEvent(-1, "Radio2Click")
GUICtrlCreateGroup("", -99, -99, 1, 1)
;******************************************************************************************
;******************************************************************************************
$Spieler = GUICtrlCreateGroup("", 36, 179, 715, 314)

$Leiste = GUICtrlCreateInput("", 50, 360, 660, 50, BitOR($ES_READONLY, $ES_AUTOHSCROLL))
GUICtrlSetFont(-1, 24, 800, 0, "Times New Roman")
GUICtrlSetBkColor(-1, 0xffffaa)
GUICtrlSetLimit(-1, 24)

$Fortschritt1 = GUICtrlCreateProgress(50, 414, 660, 10)

$Fortschritt2 = GUICtrlCreateProgress(50, 334, 660, 20)

$Eingabe = GUICtrlCreateInput("", 200, 445, 400, 30)
GUICtrlSetFont(-1, 16, 800, 0, "Times New Roman")
GUICtrlSetOnEvent(-1, "EingabeChange")

$FehlerText = GUICtrlCreateLabel(" Fehler: ", 80, 185, 269, 49)
GUICtrlSetFont(-1, 24, 400, 0, "Arial Black")

$FehlerAnz = GUICtrlCreateLabel("0", 220, 185, 110, 49)
GUICtrlSetFont(-1, 24, 800, 0, "Arial Black")

$PunkteText = GUICtrlCreateLabel("+", 300, 195, 20, 49)
GUICtrlSetFont(-1, 18, 800, 0, "Arial Black")

$Punkte = GUICtrlCreateLabel("0 (0)", 344, 195, 210, 49)
GUICtrlSetFont(-1, 18, 800, 0, "Arial Black")

$GesamtPunkte = GUICtrlCreateLabel("000.000.000.000 ", 344, 230, 350, 49)
GUICtrlSetFont(-1, 24, 800, 0, "Arial Black")

$Punktestand = GUICtrlCreateLabel(" Punktestand: ", 80, 230, 269, 49)
GUICtrlSetFont(-1, 24, 400, 0, "Arial Black")

$TextLevel = GUICtrlCreateLabel(" Level: ", 204, 275, 131, 49)
GUICtrlSetFont(-1, 24, 400, 0, "Arial Black")

$Lev = GUICtrlCreateLabel("0", 343, 275, 75, 49)
GUICtrlSetFont(-1, 24, 400, 0, "Arial Black")
GUICtrlCreateGroup("", -99, -99, 1, 1)

;******************************************************************************************
;******************************************************************************************
$Speedmeter = GUICtrlCreateGroup("Tacho", 50, 440, 120, 32)
$Speed = GUICtrlCreateLabel("30000 ms / Wort", 65, 455, 90, 20)
GUICtrlCreateGroup("", -99, -99, 1, 1)
;******************************************************************************************
;******************************************************************************************
DateiTest(); testen, ob alle Dateien (Wörterbuch, Highscore, Grafiken und Sounds) vorhanden sind (neu erstellen bzw. Programm beenden)

$Pic1 = GUICtrlCreatePic("gfx\achtung.gif", 715, 368, 32, 32)
GUICtrlSetState(-1, $GUI_HIDE)

$Pic2 = GUICtrlCreatePic("gfx\umlaute_nein.gif", 560, 282, 32, 32)
GUICtrlSetState(-1, $GUI_SHOW)
GUICtrlSetTip(-1, "Umlaute erst ab Level:" & $SpSt[1])

$Pic3 = GUICtrlCreatePic("gfx\gross_nein.gif", 610, 282, 32, 32)
GUICtrlSetState(-1, $GUI_SHOW)
GUICtrlSetTip(-1, "Groß-/Kleinschreibung erst ab Level:" & $SpSt[0])

$Pic4 = GUICtrlCreatePic("gfx\zeit_ja.gif", 560, 190, 32, 32)
GUICtrlSetState(-1, $GUI_SHOW)
GUICtrlSetTip(-1, "Sollte die Zeit noch nicht abgelaufen sein," & @CRLF & "erhält man die Restzeit als Bonus." & @CRLF & "Diese steht in Klammern hinter der Punktzahl.")

$Pic5 = GUICtrlCreatePic("gfx\x2_nein.gif", 610, 190, 32, 32)
GUICtrlSetState(-1, $GUI_SHOW)
GUICtrlSetTip(-1, "Im Anfänger-Modus gibt es nur einfache Punkte.")
;******************************************************************************************
;******************************************************************************************
$Startbutton = GUICtrlCreateButton("Start", 240, 125, 154, 46)
GUICtrlSetFont(-1, 16, 400, 0, "Arial Black")
GUICtrlSetOnEvent(-1, "StartClick")

$Pausebutton = GUICtrlCreateButton("Pause", 419, 125, 154, 46)
GUICtrlSetFont(-1, 16, 400, 0, "Arial Black")
GUICtrlSetOnEvent(-1, "PauseClick")
GUICtrlSetState(-1, $GUI_DISABLE)

$Stopbutton = GUICtrlCreateButton("Stop", 598, 125, 154, 46)
GUICtrlSetFont(-1, 16, 400, 0, "Arial Black")
GUICtrlSetOnEvent(-1, "StopClick")
GUICtrlSetState(-1, $GUI_DISABLE)
;******************************************************************************************
;******************************************************************************************
$TabBest = GUICtrlCreateTabItem("Bestenliste")
$Liste = GUICtrlCreateListView(" Platz | Punkte   | Name      | Level   | Anf/Pro | Fehler | Datum        ", 63, 122, 666, 358)
For $i = 1 To 50
	$pl = StringFormat("%02u", ($i))
	$HSeintrag[$i] = GUICtrlCreateListViewItem($pl & "|" & $Highscore[$i], $Liste)
Next
$ZT = GUICtrlCreateTabItem("")

$Titel = GUICtrlCreateLabel("Speedwriter v2.9.1 ", 207, 15, 400, 64)
GUICtrlSetFont(-1, 32, 400, 0, "Arial Black")
;******************************************************************************************
;******************************************************************************************
$Programm = GUICtrlCreateMenu("Programm")

$Sladen = GUICtrlCreateMenuItem("Spielstand laden...", $Programm)
GUICtrlSetOnEvent(-1, "SpstLaden")

$Ende = GUICtrlCreateMenuItem("Beenden", $Programm)
GUICtrlSetOnEvent(-1, "Beenden")

$Info = GUICtrlCreateMenu("Info")

$Hilfe = GUICtrlCreateMenuItem("Hilfe...", $Info)
GUICtrlSetOnEvent(-1, "HelpMe")

$Ueber = GUICtrlCreateMenuItem("Über...", $Info)
GUICtrlSetOnEvent(-1, "UeberClick")

;******************************************************************************************
;******************************************************************************************

Global $sndOk = _SoundOpen("snd\wort-ok.mp3")
Global $sndErr = _SoundOpen("snd\wort-fehler.mp3")
Global $sndFan = _SoundOpen("snd\tusch.mp3")

$Wortzahl = FileReadLine($Woerterbuch, 1); Die Anzahl der Wörter in der Wörterbuch-Datei steht in der ersten Zeile

GUISetState(@SW_SHOW); Fenster sichtbar machen

NeustartInit(); alle Variablenwerte auf Anfang setzen
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; Hauptschleife
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
While 1
	GUICtrlSetState($Eingabe, $GUI_DISABLE); Eingabe nicht möglich
	GUICtrlSetState($Sladen, $GUI_ENABLE); Spielstand laden ermöglichen
	While $Start = 0; Warten bis der Start-Button angeklickt wurde
		Sleep(10); irgendwann in dieser Schleife wird ein Spielstand geladen, auf Anf/Pro umgeschaltet
	WEnd; oder der Start-Button gedrückt (GUICtrlSetOnEvent)
	GUICtrlSetState($Sladen, $GUI_DISABLE); Spielstand laden nicht möglich
	GUICtrlSetState($Eingabe, $GUI_ENABLE); Eingabe jetzt ermöglichen
	GUICtrlSetState($Eingabe, $GUI_FOCUS); Den Focus auf das Eingabefeld
	For $Le = $LeSt To 30; von hier an 30 Level. Bzw. ab $LeSt (Spielstand geladen)
		GUICtrlSetData($Lev, $Le); Level anzeigen
		If $Le >= $SpSt[0] Then GUICtrlSetImage($Pic3, "gfx\gross_ja.gif")
		For $Wort = $WoSt To $Anz; Die Variable $Anz enthält die Anzahl der Wörter pro Level. Wird ganz oben zugewiesen.
			GUICtrlSetData($Fortschritt2, Int((100 / $Anz) * $Wort)); Fortschrittsbalken, wie viele Wörter bereits generiert wurden
			If $Le < $SpSt[1] Then; Im Anfänger-Modus werden Wörter mit Umlauten in den ersten 5 Leveln ($SpSt[1]) nicht generiert
				Do
					$Ra = Random(2, $Wortzahl, 1); Zufallszahl = 2 (in der 2. Zeile steht das 1 Wort) bis $Wortzahl (Wortzahl enthält die Anzahl der Wörter im Wörterbuch)
					$RaWo = FileReadLine($Woerterbuch, $Ra); zufälliges Wort aus dem Wörterbuch holen
				Until (StringIsASCII($RaWo) = 1); verhindert Wörter mit Umlauten
			Else
				GUICtrlSetImage($Pic2, "gfx\umlaute_ja.gif")
				$Ra = Random(2, $Wortzahl, 1); Zufallszahl = 2 (in der 2. Zeile steht das 1 Wort) bis $Wortzahl (Wortzahl enthält die Anzahl der Wörter im Wörterbuch)
				$RaWo = FileReadLine($Woerterbuch, $Ra); zufälliges Wort aus dem Wörterbuch holen
			EndIf
			If StringInStr($RaWo, "/") > 0 Then; Eventuelle Endung entfernen
				$RaWo = StringLeft($RaWo, StringInStr($RaWo, "/") - 1)
			EndIf
			If $Le < $SpSt[0] Then $RaWo = StringLower($RaWo); Im Anfänger-Modus werden in den ersten 10 Leveln ($SpSt[0]) alle Wörter kleingeschrieben
			GUICtrlSetData($Fortschritt1, 100)
			For $J = StringLen($RaWo) To 1 Step -1; Das generierte Wort buchstabenweise ins Bild schieben
				$Text = StringMid($RaWo, $J, 1) & $Text
				GUICtrlSetData($Leiste, $Text)
				Sleep(50)
			Next
			$H = Number(StringMid($Geschwindigkeit, $Le * 2 + 1, 2)); Antwortgeschwindigkeit holen...
			GUICtrlSetData($Speed, String(Int(30000 / $H)) & " ms / Wort"); und im Tacho anzeigen
			$ZeitStart = TimerInit()
			For $X = 100 To 0 Step -$H; das ist die Verzögerungsschleife (100 * 300 Step -$H)
				GUICtrlSetData($Fortschritt1, $X); Fortschrittbalken anzeigen
				Sleep(300)
				GUICtrlSetData($Leiste, $Text)
				If WinExists("Speedwriter stoppen...") Then; Der Benutzer hat auf Stop geklickt
					GUICtrlSetData($Leiste, "...Stop...")
					GUICtrlSetState($Leiste, $GUI_DISABLE)
					WinWaitClose("Speedwriter stoppen..."); warten, bis das Fenster geschlossen wird
					GUICtrlSetState($Leiste, $GUI_ENABLE)
					GUICtrlSetData($Leiste, $Text)
				EndIf
				$Temp = PixelSearch(680, 412, 708, 455, 0x000000); prüfen, ob der Text in der $Leiste den rechten Rand erreicht hat
				If Not @error Then
					GUICtrlSetState($Pic1, $GUI_SHOW); wenn ja, die Achtungs-Bitmap anzeigen
				Else
					GUICtrlSetState($Pic1, $GUI_HIDE); wenn nein, wieder verstecken
				EndIf
				If $Schleife = 1 Then; wenn das Wort bereits vor Ablauf der Zeit eingegeben wurde...
					If $Text = "" Then; und die $Leiste leer ist...
						$Schleife = 0
						$ZeitUm -= 1
						ExitLoop; dann gleich das nächste Wort generieren, damit der User nicht solange warten muss.
					EndIf
				EndIf
				If (StringLen($Text) > 60) Or ($Stop = 1) Then; Abbruchbedingung: mehr als 60 Buchstaben oder Benutzer hat Stop gedrückt
					Bestenliste(); Bestenliste anzeigen und gegebenenfalls eintragen
					NeustartInit()
					ExitLoop 3; In die äußerste While-Schleife springen
				EndIf
			Next
			$ZeitUm += 1; wird für jedes Wort um eins erhöht
			If $ZeitUm > 0 Then; Die Zeit für das Wort ist abgelaufen
				GUICtrlSetImage($Pic4, "gfx\zeit_nein.gif")
			Else
				GUICtrlSetImage($Pic4, "gfx\zeit_ja.gif")
			EndIf
			$Schleife = 0; Wert zurücksetzen
		Next
		$WoSt = 1; evtl. geladenen Spielstand für den nächsten Durchlauf auf 1 setzen
	Next
	$LeSt = 1; evtl. geladenen Spielstand für den nächsten Durchlauf auf 1 setzen
WEnd
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
;******************************************************************************************
; Menü 'Über...'
;******************************************************************************************
Func UeberClick()
	MsgBox(64, "Speedwriter", "Version: 2.9.1.0 (28. Januar 2010)" & @CRLF & @CRLF & "Copyright: Oscar (www.autoit.de)", 10)
EndFunc   ;==>UeberClick
;******************************************************************************************
; Hier werden alle Variablen und alle GUI-Elemente wieder in den Anfangszustand versetzt
;******************************************************************************************
Func NeustartInit()
	$Text = ""; alle Variablen wieder auf Anfangszustand setzten...
	$LeSt = 1
	$WoSt = 1
	$Punktzahl = 0
	$Fehler = 0
	$Start = 0
	$PT = 0
	$Schleife = 0
	$ZeitUm = 0
	$PauseZeit = 0
	$Zeit = 0
	$Stop = 0
	ZeigePunkte(); und für einen neuen Anfang vorbereiten.
	Radio1Click()
	GUICtrlSetData($PunkteText, "+")
	GUICtrlSetData($Lev, 0)
	GUICtrlSetData($Fortschritt1, 0)
	GUICtrlSetData($Fortschritt2, 0)
	GUICtrlSetData($Leiste, "")
	GUICtrlSetState($Pic1, $GUI_HIDE)
	GUICtrlSetImage($Pic4, "gfx\zeit_ja.gif")
	GUICtrlSetImage($Pic5, "gfx\x2_nein.gif")
	GUICtrlSetState($Startbutton, $GUI_ENABLE)
	GUICtrlSetState($Radio1, $GUI_ENABLE)
	GUICtrlSetState($Radio1, $GUI_CHECKED)
	GUICtrlSetState($Radio2, $GUI_ENABLE)
	GUICtrlSetState($Pausebutton, $GUI_DISABLE)
	GUICtrlSetState($Stopbutton, $GUI_DISABLE)
EndFunc   ;==>NeustartInit
;******************************************************************************************
; Diese Funktion wird ausgelöst durch einen Klick auf den Start-Button
;******************************************************************************************
Func StartClick()
	GUICtrlSetState($Startbutton, $GUI_DISABLE)
	GUICtrlSetState($Radio1, $GUI_DISABLE)
	GUICtrlSetState($Radio2, $GUI_DISABLE)
	GUICtrlSetState($Pausebutton, $GUI_ENABLE)
	GUICtrlSetState($Stopbutton, $GUI_ENABLE)
	$Start = 1
	GUICtrlSetState($Eingabe, $GUI_FOCUS)
EndFunc   ;==>StartClick
;******************************************************************************************
; Radio-Button (Anfänger)
;******************************************************************************************
Func Radio1Click()
	$Geschwindigkeit = $GeschAnf
	$SpSt[0] = 10
	$SpSt[1] = 5
	$Sp = 1
	$Schw = "Anf"
	GUICtrlSetData($Speed, "30000 ms / Wort")
	GUICtrlSetImage($Pic2, "gfx\umlaute_nein.gif")
	GUICtrlSetTip($Pic2, "Umlaute erst ab Level:" & $SpSt[1])
	GUICtrlSetImage($Pic3, "gfx\gross_nein.gif")
	GUICtrlSetTip($Pic3, "Groß-/Kleinschreibung erst ab Level:" & $SpSt[0])
	GUICtrlSetImage($Pic5, "gfx\x2_nein.gif")
	GUICtrlSetTip($Pic5, "Im Anfänger-Modus gibt es nur einfache Punkte.")
EndFunc   ;==>Radio1Click
;******************************************************************************************
; Radio-Button (Profi)
;******************************************************************************************
Func Radio2Click()
	$Geschwindigkeit = $GeschPro
	$SpSt[0] = 0
	$SpSt[1] = 0
	$Sp = 2
	$Schw = "Pro"
	GUICtrlSetData($Speed, "10000 ms / Wort")
	GUICtrlSetImage($Pic2, "gfx\umlaute_ja.gif")
	GUICtrlSetTip($Pic2, "Umlaute sofort.")
	GUICtrlSetImage($Pic3, "gfx\gross_ja.gif")
	GUICtrlSetTip($Pic3, "Groß-/Kleinschreibung sofort.")
	GUICtrlSetImage($Pic5, "gfx\x2_ja.gif")
	GUICtrlSetTip($Pic5, "Im Profi-Modus gibt es die doppelte Punktzahl.")
EndFunc   ;==>Radio2Click
;******************************************************************************************
; Diese Funktion wird aufgerufen, wenn auf den Pause-Button geklickt wird
;******************************************************************************************
Func PauseClick()
	$PauseZeit = TimerInit(); Zeit der Pause messen, um sie später von der Wortzeit abziehen zu können, damit der Zeitbonus erhalten bleibt
	GUICtrlSetData($Leiste, "...Pause..."); In der Leiste "Pause" anzeigen, um ein schummeln zu vermeiden
	GUICtrlSetState($Pausebutton, $GUI_DISABLE); Buttons sperren
	GUICtrlSetState($Stopbutton, $GUI_DISABLE)
	GUICtrlSetState($Leiste, $GUI_DISABLE)
	MsgBox(64, "Speedwriter", "Du kannst jetzt eine Pause einlegen," & @CRLF & "Zum Weiterspielen musst Du [ok] anklicken."); warten auf [ok]
	$PauseZeit = TimerDiff($PauseZeit); In dieser Variablen wird die Pausenzeit abgelegt
	GUICtrlSetData($Leiste, $Text); wieder den ursprünglichen Text anzeigen
	GUICtrlSetState($Pausebutton, $GUI_ENABLE); Buttons wieder freigeben
	GUICtrlSetState($Stopbutton, $GUI_ENABLE)
	GUICtrlSetState($Leiste, $GUI_ENABLE)
	GUICtrlSetState($Eingabe, $GUI_FOCUS)
EndFunc   ;==>PauseClick
;******************************************************************************************
; Diese Funktion wird bei jeder Eingabe eines Buchstaben aufgerufen
;******************************************************************************************
Func EingabeChange()
	$E = GUICtrlRead($Eingabe)
	If StringRight($E, 1) = " " Then
		$E = StringTrimRight($E, 1)
		$Zeit = Int(TimerDiff($ZeitStart)) - $PauseZeit
		$PauseZeit = 0
		$Zeit = Int((30000 - $Zeit) / 100)
		$L = StringLen($E)
		If $E == StringRight($Text, $L) Then; Stimmt das Wort überein?
			$Schleife = 1; wird in der Hauptschleife gebraucht um festzustellen, ob schon das nächste Wort generiert werden kann
			_SoundPlay($sndOk, 0)
			If $ZeitUm > 0 Then; wenn die Zeit für das Wort bereits abgelaufen ist,
				$Zeit = 0; gibt es keinen Zeitbonus
				$ZeitUm -= 1; der Zähler wird um eins herabgesetzt
				If $ZeitUm > 0 Then; prüfen, ob noch mehrere Zeitboni abgelaufen sind
					GUICtrlSetImage($Pic4, "gfx\zeit_nein.gif"); dementsprechend die Zeitgrafik auf NEIN
				Else
					GUICtrlSetImage($Pic4, "gfx\zeit_ja.gif"); oder JA setzen
				EndIf
			EndIf
			$PT = ($L * $L * $Le + $Zeit) * $Sp; Die Punkte zusammenzählen (Stringlänge*Stringlänge*Level+Zeitbonus)*Spielstärke (Pro=2, Anf=1)
			GUICtrlSetData($PunkteText, "+")
			Bonuspunkte(); hier gibt es noch evtl. Bonuspunkte auf einige Buchstaben
			$PT += $Bonus
			$Punktzahl += $PT; Die Gesamtpunktzahl um die Punkte erhöhen
			ZeigePunkte(); und anzeigen
			$Text = StringLeft($Text, StringLen($Text) - $L); Die Textzeile kann um den richtigen Teil gekürzt werden
			GUICtrlSetData($Leiste, $Text); die geänderte Textzeile anzeigen
		Else; Das Wort stimmt nicht überein
			_SoundPlay($sndErr, 0)
			$Fehler += 1; Fehlerzähler um eins erhöhen
			If $ZeitUm > 0 Then $Zeit = 0; wenn die Zeit bereits abgelaufen war, wird der Zeitbonus nicht mit abgezogen
			$PT = ($L * $L * $Le + $Zeit) * $Sp; Die Punkte zusammenzählen (Stringlänge*Stringlänge*Level+Zeitbonus)*Spielstärke (Pro=2, Anf=1)...
			GUICtrlSetData($PunkteText, "-")
			$Punktzahl -= $PT; ...und von der Gesamtpunkzahl abziehen.
			If $Punktzahl < 0 Then $Punktzahl = 0; keine negative Punktzahl!
			ZeigePunkte(); Punktzahl anzeigen
		EndIf
		GUICtrlSetData($Eingabe, ""); das Eingabefeld löschen
	EndIf
EndFunc   ;==>EingabeChange
;******************************************************************************************
; Hier werden die Punkte und Fehler dem Benutzer angezeigt
;******************************************************************************************
Func ZeigePunkte()
	$P = StringRight("000000000000" & String($Punktzahl), 12)
	$P = StringLeft($P, 3) & "." & StringMid($P, 4, 3) & "." & StringMid($P, 7, 3) & "." & StringRight($P, 3)
	GUICtrlSetData($GesamtPunkte, $P)
	GUICtrlSetData($Punkte, $PT & " (" & $Zeit & ")")
	GUICtrlSetData($FehlerAnz, $Fehler)
EndFunc   ;==>ZeigePunkte
;******************************************************************************************
; hier wird geprüft, ob einige 'Bonus'-Buchstaben in dem Wort enthalten sind
;******************************************************************************************
Func Bonuspunkte()
	$Bonus = 0
	$Bonusb = "öäüÖÄÜß-zyxqZYXQ."; Diese Buchstaben erhalten einen zusätzlichen Bonus
	For $b1 = 1 To StringLen($E); prüfen ob Bonus-Buchstaben in der Eingabe ($E) enthalten sind
		For $b2 = 1 To StringLen($Bonusb)
			If StringMid($E, $b1, 1) == StringMid($Bonusb, $b2, 1) Then $Bonus += 100 * $Le
		Next
	Next
EndFunc   ;==>Bonuspunkte
;******************************************************************************************
; Diese Funktion wird aufgerufen, wenn der Benutzer das Programm beenden will
;******************************************************************************************
Func Beenden()
	$PauseZeit = TimerInit(); Zeit der "Beenden-Pause" messen, um sie später von der Wortzeit abziehen zu können (damit der Zeitbonus erhalten bleibt), sollte der Benutzer auf [Nein} klicken
	GUICtrlSetData($Leiste, "...Beenden?...")
	GUICtrlSetState($Leiste, $GUI_DISABLE)
	$abr = MsgBox(36, "Speedwriter", "Programm beenden?")
	If $abr = 6 Then Ende(); Benutzer hat 'Ja' angeklickt, also Programm beenden
	$PauseZeit = TimerDiff($PauseZeit); ansonsten die "Beenden-Pausenzeit" hier eintragen
	GUICtrlSetData($Leiste, $Text)
	GUICtrlSetState($Leiste, $GUI_ENABLE)
	GUICtrlSetState($Eingabe, $GUI_FOCUS)
EndFunc   ;==>Beenden
;******************************************************************************************
; Diese Funktion ruft noch einige endgültige Befehle auf, bevor es dann das Programm beendet
;******************************************************************************************
Func Ende()
	FileClose($Woerterbuch)
	_SoundClose($sndErr)
	_SoundClose($sndOk)
	_SoundClose($sndFan)
	Exit
EndFunc   ;==>Ende
;******************************************************************************************
; evtl. Eintrag in die Bestenliste und abspeichern derselben
;******************************************************************************************
Func Bestenliste()
	GUICtrlSetState($TabBest, $GUI_SHOW)
	$Platz = 0
	For $i = 1 To 50; Suchen, ob die Punktzahl ausreicht einen der 50 Plazierungen einzunehmen
		If $P > StringLeft($Highscore[$i], 15) Then; Punktzahl ist größer als ein Eintrag in der Liste, dann...
			_SoundPlay($sndFan, 0); Sound abspielen
			Do
				$Name = InputBox("Speedwriter", "Bitte gib Deinen Namen ein:", "", " M25", 300, 120); Namen eingeben
			Until @error = 0; warten bis wirklich ein Name eingegeben wurde
			If $i < 50 Then
				For $J = 50 To $i + 1 Step -1; Die anderen Highscore-Einträge einen nach unten verschieben
					$Highscore[$J] = $Highscore[$J - 1]
				Next
			EndIf
			$Highscore[$i] = $P & "|" & $Name & "|" & $Le & "|" & $Schw & "|" & $Fehler & "|" & _NowDate(); Neuen Eintrag generieren
			$Platz = $i
			ExitLoop
		EndIf
	Next
	For $i = 1 To 50; Highscore-Liste auf der Benutzeroberfläche anzeigen
		$pl = StringFormat("%02u", ($i))
		GUICtrlSetData($HSeintrag[$i], $pl & "|" & $Highscore[$i])
	Next
	If $Platz = 0 Then
		MsgBox(0, "Speedwriter", "Deine Punktzahl reicht leider nicht aus" & @CRLF & "für einen Eintrag in die Bestenliste.")
	Else
		_FileWriteFromArray("sys\hs.sw", $Highscore, 1); und auf Festplatte sichern
		$r = _Crypt_HashFile("sys\hs.sw", $CALG_MD5)
		$r = _StringEncrypt(1, $r, "DaLeiseiNeunKr"); verschlüsseln (um eine Manipulation zu erschweren)...
		$hFile = FileOpen("sys\hs_check.sw", 2)
		If $hFile <> -1 Then
			FileWrite($hFile, $r); und auf Festplatte sichern
			FileClose($hFile)
		EndIf
	EndIf
EndFunc   ;==>Bestenliste
;******************************************************************************************
; Bestenliste neu generieren
;******************************************************************************************
Func ListeNeu()
	For $i = 1 To 50; Highscore-Liste neu erstellen
		$Highscore[$i] = "000.000.000.000|Speedwriter              |0|Anf|0|" & _NowDate()
	Next
	_FileWriteFromArray("sys\hs.sw", $Highscore, 1)
	$r = _Crypt_HashFile("sys\hs.sw", $CALG_MD5)
	$r = _StringEncrypt(1, $r, "DaLeiseiNeunKr")
	$hFile = FileOpen("sys\hs_check.sw", 2)
	If $hFile <> -1 Then
		FileWrite($hFile, $r); und auf Festplatte sichern
		FileClose($hFile)
	EndIf
EndFunc   ;==>ListeNeu
;******************************************************************************************
; Testen, ob alle Dateien vorhanden sind und ob wichtige Dateien unverändert sind
;******************************************************************************************
Func DateiTest()
	; Bestenliste vorhanden?
	If FileExists("sys\hs.sw") Then
		$r1 = FileRead("sys\hs_check.sw")
		$r1 = _StringEncrypt(0, $r1, "DaLeiseiNeunKr")
;~ 		$r = DllCall("sys\md5.dll", "str", "GetMD5FromFile", "str", "sys\hs.sw")
		$r = _Crypt_HashFile("sys\hs.sw", $CALG_MD5)
		If $r <> $r1 Then
			MsgBox(48, "Speedwriter", "Die Bestenliste wurde verändert." & @CRLF & "Die Liste wird neu erstellt.")
			ListeNeu()
		Else
			_FileReadToArray("sys\hs.sw", $Highscore)
		EndIf
	Else
		MsgBox(48, "Speedwriter", "Die Bestenliste fehlt." & @CRLF & "Die Liste wird neu erstellt.")
		ListeNeu()
	EndIf
	; Wörterbuch vorhanden
	If FileExists("sys\d.dic") Then
		$r2 = FileRead("sys\d_check.sw")
		$r2 = _StringEncrypt(0, $r2, "DaLeiseiNeunKr")
		$r = _Crypt_HashFile("sys\d.dic", $CALG_MD5)
		If $r <> $r2 Then
			MsgBox(48, "Speedwriter", "Das Wörterbuch wurde verändert." & @CRLF & "Programm wird beendet.")
			Exit
		EndIf
		$Woerterbuch = FileOpen("sys\d.dic", 0)
		If $Woerterbuch = -1 Then
			MsgBox(16, "Speedwriter", "Wörterbuch-Datei konnte nicht geöffnet werden." & @CRLF & "Das Programm wird beendet!")
			Exit
		EndIf
	Else
		MsgBox(16, "Speedwriter", "Wörterbuch-Datei fehlt oder beschädigt." & @CRLF & "Das Programm wird beendet!")
		Exit
	EndIf
	; Grafiken und Sounds vorhanden?
	$Test = "gfx\achtung.gif|gfx\gross_ja.gif|gfx\gross_nein.gif|gfx\umlaute_ja.gif|gfx\umlaute_nein.gif|gfx\x2_ja.gif|"
	$Test &= "gfx\x2_nein.gif|gfx\zeit_ja.gif|gfx\zeit_nein.gif|snd\tusch.mp3|snd\wort-ok.mp3|snd\wort-fehler.mp3|"
	Do
		$Temp = StringLeft($Test, StringInStr($Test, "|") - 1)
		If Not FileExists($Temp) Then
			MsgBox(16, "Speedwriter", "Die Datei '" & $Temp & "' fehlt oder ist beschädigt!" & @CRLF & "Das Programm wird beendet.")
			FileClose($Woerterbuch)
			Exit
		EndIf
		$Test = StringTrimLeft($Test, StringInStr($Test, "|"))
	Until $Test = ""
EndFunc   ;==>DateiTest
;******************************************************************************************
; Der Benutzer hat den Stop-Button angeklickt
;******************************************************************************************
Func StopClick()
	GUICtrlSetState($Stopbutton, $GUI_DISABLE)
	GUICtrlSetState($Pausebutton, $GUI_DISABLE)
	GUICtrlSetData($Leiste, "...Stop...")
	$Form2 = GUICreate("Speedwriter stoppen...", 440, 160, -1, -1, -1, -1, $Form1); neues Fenster öffnen
	GUISetIcon("sys\Speedwriter.ico")
	GUISetOnEvent($GUI_EVENT_CLOSE, "zurueckClick")
	GUISetState(@SW_SHOW)
	$SpielstandGroup = GUICtrlCreateGroup("Spielstand...", 20, 20, 400, 100)
	GUICtrlSetColor(-1, 0x000000)
	$Radio3 = GUICtrlCreateRadio("Spielstand in die Bestenliste eintragen und Spiel neu beginnen.", 60, 50, 330, 18)
	GUICtrlSetState(-1, $GUI_CHECKED + $GUI_FOCUS)
	$Radio4 = GUICtrlCreateRadio("Spielstand (auf Festplatte) speichern und Programm beenden.", 60, 80, 330, 18)
	GUICtrlCreateGroup("", -99, -99, 1, 1)
	$Abbruchbutton = GUICtrlCreateButton("zurück", 100, 125, 100, 24)
	GUICtrlSetFont(-1, 10, 400, 0, "Arial Black")
	GUICtrlSetOnEvent(-1, "zurueckClick")
	$Weiterbutton = GUICtrlCreateButton("weiter...", 220, 125, 100, 24)
	GUICtrlSetFont(-1, 10, 400, 0, "Arial Black")
	GUICtrlSetOnEvent(-1, "WeiterClick")
	Do
		Sleep(50)
	Until 1
EndFunc   ;==>StopClick
;******************************************************************************************
; Der Benutzer hat im Stop-Fenster [zurück] angeklickt
;******************************************************************************************
Func zurueckClick()
	GUICtrlSetState($Pausebutton, $GUI_ENABLE)
	GUICtrlSetState($Stopbutton, $GUI_ENABLE)
	GUIDelete($Form2)
EndFunc   ;==>zurueckClick
;******************************************************************************************
; Der Benutzer hat im Stop-Fenster [weiter...] angeklickt
;******************************************************************************************
Func WeiterClick()
	If GUICtrlRead($Radio3) = $GUI_CHECKED Then
		$Stop = 1; nur den Spielstand in die Bestenliste eintragen und neu beginnen
	Else; Spielstand auf Festplatte speichern
		$tmp = "Bitte gib einen Dateinamen ein, unter dem" & @CRLF & "der Spielstand gespeichert werden soll."
		Do
			Do
				$Dateiname = InputBox("Speedwriter", $tmp, "", " M25", 320, 150); Dateiname erforderlich, aber max. 25 Zeichen
			Until $Dateiname <> ""; Leerstring bedeutet: Benutzer hat auf Abbrechen geklickt (wird ignoriert = Schleife wiederholen)
			If Not StringIsAlNum($Dateiname) Then; wenn Sonderzeichen im Dateinamen enthalten sind...
				MsgBox(48, "Speedwriter", "Bitte nur Buchstaben und Zahlen eingeben!")
				$Dateiname = ""; ...nochmal abfragen
			Else
				$DateiCheck = "sav\" & $Dateiname & "_check.sw"; Dateinamen um Verzeichnis und Endung ergänzen
				$Dateiname = "sav\" & $Dateiname & ".ini"
				If FileExists($Dateiname) Then; Prüfen, ob Datei mit diesem Dateinamen bereits vorhanden ist
					$exists = MsgBox(52, "Speedwriter", "Datei existiert bereits. Überschreiben?"); wenn vorhanden, Benutzer fragen
					If $exists = 7 Then $Dateiname = ""; Nicht überschreiben (7 = Benutzer hat Nein angeklickt). Nochmal abfragen
				EndIf
			EndIf
		Until $Dateiname <> ""; Bei Leerstring Schleife wiederholen
		$Text = StringRight($Text, StringLen($Text) - StringLen($RaWo)); Das letzte generierte Wort löschen, wegen Bonus-/Pausenzeit-Problem
		IniWrite($Dateiname, "Spielstand", "Text", $Text); Die wichtigen Variablen in die Ini-Datei speichern
		IniWrite($Dateiname, "Spielstand", "Punktzahl", $Punktzahl)
		IniWrite($Dateiname, "Spielstand", "Fehler", $Fehler)
		IniWrite($Dateiname, "Spielstand", "Schw", $Schw)
		IniWrite($Dateiname, "Spielstand", "Level", $Le)
		IniWrite($Dateiname, "Spielstand", "Wort", $Wort)
		$r = DllCall("sys\md5.dll", "str", "GetMD5FromFile", "str", $Dateiname); jetzt noch die Checksumme erstellen...
		$r[1] = ""
		$r[0] = _StringEncrypt(1, $r[0], "DaLeiseiNeunKr"); verschlüsseln (um eine Manipulation zu erschweren)...
		_FileWriteFromArray($DateiCheck, $r, 0); und auf Festplatte sichern
		GUIDelete($Form2); Das Stop-Fenster schließen
		MsgBox(64, "Speedwriter", "Spielstand gespeichert. Programm wird beendet."); Benutzer informieren
		Ende(); Ende-Funktion aufrufen
	EndIf
	GUICtrlSetState($Pausebutton, $GUI_ENABLE)
	GUICtrlSetState($Stopbutton, $GUI_ENABLE)
	GUIDelete($Form2); Das Stop-Fenster schließen
EndFunc   ;==>WeiterClick
;******************************************************************************************
; Menü 'Spielstand laden'
;******************************************************************************************
Func SpstLaden()
	$Dateiname = FileOpenDialog("Spielstand laden...", "sav\", "(*.ini)", 1 + 2); Dateiauswahlbox (nur .ini)
	FileChangeDir(@ScriptDir); Das Working-Directory wieder auf das Programm-Verzeichnis setzen
	If $Dateiname <> "" Then
		$DateiCheck = StringLeft($Dateiname, StringInStr($Dateiname, ".") - 1) & "_check.sw"; Namen der Checksummen-Datei generieren
		If FileExists($DateiCheck) Then; und prüfen, ob sie vorhanden ist
			_FileReadToArray($DateiCheck, $r1); Checksummendatei vorhanden, wird ins Array $r eingelesen
			$r1[1] = _StringEncrypt(0, $r1[1], "DaLeiseiNeunKr"); entschlüsselt
			$r = DllCall("sys\md5.dll", "str", "GetMD5FromFile", "str", $Dateiname); Checksumme der Spielstandsdatei generieren
			If $r[0] <> $r1[1] Then; prüfen, ob die Spielstandsdatei verändert wurde
				MsgBox(48, "Speedwriter", "Die Spielstands-Datei wurde verändert." & @CRLF & "Spielstand kann nicht geladen werden.")
				$Dateiname = ""; Spielstand wird nicht geladen
			EndIf
		Else; Checksummen-Datei nicht vorhanden
			MsgBox(48, "Speedwriter", "Die Checksummen-Datei zu diesem Spielstand fehlt." & @CRLF & "Spielstand kann nicht geladen werden.")
			$Dateiname = ""; Spielstand wird nicht geladen
		EndIf
		If $Dateiname <> "" Then
			NeustartInit(); Alles für den Neustart vorbereiten
			$Text = IniRead($Dateiname, "Spielstand", "Text", 0); Spielstand laden
			$Punktzahl = IniRead($Dateiname, "Spielstand", "Punktzahl", 0)
			$Fehler = IniRead($Dateiname, "Spielstand", "Fehler", 0)
			$Schw = IniRead($Dateiname, "Spielstand", "Schw", 0)
			$LeSt = IniRead($Dateiname, "Spielstand", "Level", 0)
			$WoSt = IniRead($Dateiname, "Spielstand", "Wort", 0)
			If $Schw = "Anf" Then; weitere Vorbereitungen
				GUICtrlSetState($Radio1, $GUI_CHECKED)
				Radio1Click()
			EndIf
			If $Schw = "Pro" Then
				GUICtrlSetState($Radio2, $GUI_CHECKED)
				Radio2Click()
			EndIf
			GUICtrlSetData($Lev, $LeSt)
			ZeigePunkte()
			GUICtrlSetData($Fortschritt2, Int((100 / $Anz) * $WoSt)); Fortschrittsbalken, wie viele Wörter bereits generiert wurden
			GUICtrlSetData($Leiste, $Text)
			GUICtrlSetState($Radio1, $GUI_DISABLE)
			GUICtrlSetState($Radio2, $GUI_DISABLE)
			MsgBox(64, "Speedwriter", "Spielstand geladen."); Benutzer informieren
		EndIf
	EndIf
EndFunc   ;==>SpstLaden
;******************************************************************************************
; Menüeintrag 'Hilfe...' im Info-Menü
;******************************************************************************************
Func HelpMe()
	ShellExecute("Anleitung.html")
EndFunc   ;==>HelpMe
