PowerShell – 13 – Simpler Passwortgenerator

Save page

Ich habe mir einen einfachen Passwortgenerator mit PowerShell gebastelt. Gut, einfach nur ein Passwort generieren mit Get-Random ist relativ einfach. Doch ich wollte noch ein wenig mehr. Ich möchte bestimmen wie groß der Anteil (prozentual) von Großbuchstaben, Kleinbuchstaben, Nummern sowie Sonderzeichen ist. Soweit zur Idee.

Was habe ich im Script genutzt

Für dieses Script habe ich mehrere bereits beschriebene Elemente genutzt. Der Generator basiert auf der Funktion Get-Random, welche ich im Artikel PowerShell – 02 – Random beschrieben habe. Selbst einen Zufallsalgorithmus zu entwickeln ist hoch komplex und erfordert ebenfalls etwas mehr Zeit. Im Script setze mehrfach Get-Random ein um die zufällige Erstellung des Passwortes zu maximieren. Weiterhin habe ich die Switch- oder auch Case-Schleife verwendet. Diese habe ich im Artikel PowerShell – 11.1 – Logfiles mit einer Function erstellen näher beschrieben. Hier prüfe ich allerdings keine Worte/Zeichen sondern numerische Werte. Weiterhin lasse ich die benötigte Zeit ermitteln welche zur Erstellung des Passwortes benötigt wird. Dies kann entweder mit Measure-Command (PowerShell – Scriptdauer messen Teil 2) oder mit einer selbstgeschrieben Variante (PowerShell – Scriptdauer messen Teil 1) gemessen werden. Ich habe mich im Script für meine selbst erstellte Variante entschieden. Zu guter Letzt nutzet ich die Funktion Runden (Round) aus der Mathematikbibliothek (Math).

Input des Scriptes

Im Script müssen mehrere Variablen angeben werden. Diese habe ich in der folgenden Tabelle näher beschrieben.

Name Typ Beschreibung
$PWDLength Int32 Diese Variable legt die Länge des Passwortes fest. Definiert ist sie als Int32 damit auch besonders lange Passwörter möglich sind (bis zu 2.147.483.647 Zeichen).
$AmountABC_percent Int Diese Variable legt den prozentualen Wert der Großbuchstaben (A-Z) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf.
$AmountABCsm_percent Int Diese Variable legt den prozentualen Wert der Kleinbuchstaben fest (a-z). Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf.
$AmountNR_percent Int Diese Variable legt den prozentualen Wert der Ziffern(0-9) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf.
$AmountSign_percent Int Diese Variable legt den prozentualen Wert der Sonderzeichen ($,!,%,^) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf.
$AllAmounts_percent Int

Diese Variable fast alle $Amount* Variablen zusammen. Anschließend wird geprüft, ob diese größer gleich 100 ist. Ist sie größer als 100 wird ein Fehler ausgegeben mit dem Hinweis das die Werte angepasst werden müssen. Ist diese Variable kleiner 100 wird der Wert von $AmountABC_percent solange um jeweils 1 erhöht bis der Wert von $AllAmounts_percent 100 entspricht.

Funktionsweise des Scriptes

Nachdem die oben genannten Werte angeben sind geht es im Script wie folgt weiter. Es wird zu erst geprüft, ob die Variable $AllAmounts_percent  kleiner 100 ist. Trifft dies zu, wird der Wert der Variable $AmountABC_percent (Anzahl Großbuchstaben) jeweils um eins erhöht bis $AllAmounts_percent gleich 100 ist. Übersteigt $AllAmounts_percent jedoch den Wert 100 bricht das Script mit der Fehlermeldung „Prozentuale Werte sind über 100%!“ ab. Ausgelöst durch break.

Im nächsten Schritt werden vier Arrays ($Chars_*) initiiert für Groß- und Kleinbuchstaben, Ziffern sowie für Sonderzeichen. Diese können beliebig erweitert werden.

Nun wird eine als String deklarierte Variable $UserPassword angelegt. Die Variable wird im folgenden Switch-Statement verwendet. Dazu muss sie vorher bereits existieren. Inhalt der Variable ist am Ende das generierte Passwort.

Es werden zwei weitere Arrays gebildet, $AllAmounts_array und $AllAmountsArray. Das Array $AllAmounts_array enthält alle vier Werte der $Amount* Variablen. $AllAmountsArray wird zunächst nur initiiert. Dieses wird für die folgende For-Schleife benötigt.

In der folgenden For-Schleife kommt die Round Funktion der Math Bibliothek zum Einsatz. Hier breche ich die angegebenen prozentualen Werte auf Ganzahlen (integer) herunter. Dazu nehme ich die Länge des Passwortes geteilt durch 100. Das Ergebnis wird anschließend mit dem Wert von $AllAmounts_array[$i] multipliziert. $i entspricht jeweils dem Wert von $AmountABC_percent, $AmountABCsm_percent, $AmountNR_percent oder $AmountSign_percent.

Die gesamt ermittelten Werte von $AllAmountsArray werden auf die entsprechenden $Amount*_numeric Variablen verteilt. Es kann sein das die Gesamtsumme nicht 100 erreicht. Dies kommt durch das Runden der Prozentangaben.

In der folgenden If-Schleife wir der Wert von $AllAmounts geprüft. Ist dieser nicht 100 wird auch hier wieder der Anteil von Großbuchstaben ($AmountABC_numeric) erhöht. Somit ist gewehrleistet, das die Passwortlänge in jedem Fall erreicht wird.

Nach diesen ganzem Vorgeplänkel kommt nun der eigentliche und spannende Teil, das Zusammenstellen des Passwortes. In der Do-While-Schleife wird erst eine Wert zwischen 0 und 3 mittels Get-Random ausgewürfelt (Daran denken, dass Null auch eine Zahl ist). Die „zufällig“ generiete Zahl spring dran in einen der vier Cases. Diese habe ich in der Tabelle kurz beschrieben.

Case Was passiert
0 Es wird ein Großbuchstabe dem Passwort ($UserPassword) hinzugefügt
1 Es wird ein Kleinbuchstabe dem Passwort ($UserPassword) hinzugefügt
2 Es wird eine Ziffer dem Passwort ($UserPassword) hinzugefügt
3 Es wird ein Sonderzeichen dem Passwort ($UserPassword) hinzugefügt

Was passiert nun genau in diesem Case?  In Case 0 wird geprüft, ob der Wert von $AmountABC_numeric gleich null ist. Ist der Wert der Variable nicht null wird dieser innerhalb der If-Bedingung um eins verringert und die Variable $UserPassword wird um ein Zeichen erweitert. Hierzu wird ein Wert des Array $Chars_ABC mittels Get-Random ausgewählt. Das Maximum bei Get-Random habe ich mit $Chars_ABC.Count festgelegt. So beleibt das Script dynamisch, da z.B. das Array $Chars_Sign um weitere Sonderzeichen erweitert werden kann. Die Do-While-Schleife wird solange ausgeführt bis die Länge von $UserPassword mit der gewünschten Länge ($PWDLength) übereinstimmt. Tritt dieser Fall ein, sind alle $Amount*_numeric Variablen gleich null. Der ganze Vorgang ist analog für die anderen Cases 1-3 zu betrachten.

Hinweis zu Get-Random:
Bei Get-Random muss das Minimum nicht zwingend angegeben werden, wenn es Null ist/ sein soll. Dennoch habe ich es bei den anderen Get-Randoms angegeben. Dies wäre aber nicht nötig.

Anschließend folgt nur noch der Output. Hier wird zu erst das Passwort angezeigt, gefolgt von der Länge des Passwortes. Darunter wird noch die benötigte Zeit angeben die das Script gebraucht hat. Fertig 🙂

Weitere Features

Das Script werde ich noch als Funktion umschreiben damit die Angabe der Werte einfacher von der Hand gehen. Zudem möchte ich das Script mit einer GUI verstehen und als umgewandelte ausführbare Datei (EXE) erstellen. Sodass ein einfache Starten als Tool möglich ist. Diesen Vorgang werde ich natürlich auch hier wieder detailliert beschreiben.

Eines der größeren Schritte soll dann die Aufnahme in ein selbst erstelltes Modul werden. Das Modul soll dann mehrere praktische Scripte enthalten und stets erweitert werden. Hierzu werde ich dann eine eigene Reihe von Artikeln auf meinem Blog verfassen.

Das komplette Script

Hier nun das Script in seiner vollen Länge mit Header und Versionsverwaltung. Beispielausgaben des Scriptes stehen darunter.

Ausgabe des Script

Mit steigender Länge des Passwortes benötigt das Script entsprechend mehr Zeit. Das Script lässt sich garantiert noch etwas performanter gestalten, aber ich denke für ein Passwort mit 100 Stellen sind 75 ms ganz in Ordnung.Aus optischen Gründen habe ich die Passwörter in der Ausgabe als String in Kochkommas gestellt. Dieser werden in der normalen Ausgabe nicht angezeigt.

 

Viele Grüße

rewe

 

PowerShell – 11.1 – Logfiles mit einer Function erstellen

Save page

Ein gutes Script hat auch ein Log. Das ist Fakt. Sobald Daten beispielweise im AD geändert werden, ist es erforderlich ein Log zu schreiben. Denn wer weiß, wann man die Änderung nochmal rückgängig machen muss oder ähnliches. Für einige Scripte habe ich mir eine Funktion geschrieben die zu einem die Eingabe etwas vereinfachen und etwas die Schreibarbeit verringern soll. Ziel ist es das Log in ein Text-File zuschreiben und in der Console mitlaufen zulassen. Ein weiteres Ziel ist dabei die Formatierung nicht immer wieder erneut zu wiederholen. Der Code wir schnell unübersichtlich bei einer Zeile für das Log und einer Zeile für die Ausgabe in der Console. Wenn nun einmal etwas im Log angepasst werden muss, dann darf ich durch das ganze Script gehen und schauen wo ich einmal einen Logeintrag generiere und muss jeweils zwei Zeilen anpassen. Dieser Mehraufwand soll verhindert werden. Ferner könnte ich auch eine Mail-Funktion in die Write-LOG Funktion implementieren und bei gewissen Werten, automatisch eine Mail versenden lassen.

Ich nutze hier nicht die Foreach- oder For-Schleife. In diesem Falle nutze ich das Switch Statement oder auch Case-Abfrage, Case-Schleife. Ziel ist es hier das seltener verwendete Switch Statement in einem praktischen Beispiel zu verwenden. Dies sieht bei gezielten Abfragen auch etwas übersichtlicher aus, als alles in If-Schleifen zu packen.

Das Funktion muss bei PowerShell oberhalb im Script stehen. Siehe dazu PowerShell – 11 – Funktionen (Functions).

Aufbau Write-LOG; Erklärung Switch Statement

Ich habe meine Funktion an die Standardfunktionen wie write-host angelehnt und nenne sie passender Weise Write-LOG. Intern verwende ich dann das besagte Switch Statement.

Die Funktion erwartet zwei Input-Werte, zu einem eine $Info und den $Status.
$Info enthält die Information die in das Log-File geschrieben werden sollen und $Status enthält den Wert, welcher für die jeweiligen Case zutreffend ist.
$Status kann folgende Werte annehmen, welche in einem Fall (Case) münden:

  • Info
  • Status
  • Warning
  • Error

Hauptsächlich dienen die Fälle (Cases) in meinem Beispiel dazu die Farbe der Schrift in der Console zu definieren. So sind Infos stets Grün, eine Warnung Gelb und Error-Meldungen Rot mit Weißen Hintergrund.

Wie Switch Statement funktioniert

In einem Switch-Statement wird jeweils ein Wert geprüft, ob dieser gleich einem der abgegeben Cases ist. Dieser Vorgang ist nicht Case sensitiv. Heißt Groß- und Kleinschreibung ist egal. Bei Übereinstimmung, also im Beispiel $Status ist gleich „Info“, „Status“, „Warning“ oder „Error“, wird der jeweilige Case ausgeführt.
Sollte der Wert nicht angegeben werden, oder keiner der entsprechenden Cases zutreffen, dann gibt es noch den default-Case. Hier kann in dem Switch Statement definiert werden, was mit nicht passenden Werten geschehen soll. Der default-Case muss nicht angegeben werden. Allerdings wird dann bei nicht zutreffenden Werten auch nichts unternommen. Weite Beispiele Switch Statement (engl.).:

Semikolon nutzen in Scripten

Das Semikolon „;“ nutze ich um nicht eine zweite Zeile Code pro Case anfangen zu müssen. In anderen Programmiersprachen wie C# muss jede Codezeile die beendet wird mit einem Semikolon enden. Alles was nachdem Semikolon steht, steht quasi auf einer neuen Zeile.

Script Write-LOG

Damit die Funktion auch genutzt werden kann, hier die…

Eingabe des Write-LOG

Es gibt natürlich mehrere Varianten die Funktion zu nutzten, bzw. die Daten zu übergeben.
Variante 1 enthält im String mehre Variablen. Variante 2 ist hingegen ein reiner String und Variante 3 übergibt lediglich das Datum.

Soweit erstmal zum Thema Switch Statement.

 

rewe

 

PowerShell – 12 – Active Directory / Group Policy cmdlets aktivieren

Save page

Um die Active Directory cmdlets nutzen zu können, müssen diese erst aktiviert werden. Ein einfaches Einfügen im Modules-Verzeichnis (C:\Windows\System32\WindowsPowerShell\v1.0\Modules) reicht hier leider nicht aus. Die cmdlets können nicht geladen werden und somit auch nicht genutzt. Die Wege die cmdlets freizuschalten sind auf den beiden Systemen leicht unterschiedlich, dennoch sehr einfach. Zuerst möchte ich den Weg auf dem Windows 7 Client vorstellen anschließend wie die cmdlets auf dem Windows Server 2012 und Windows Server 2012 R2 zum Laufen gebracht werden können. Um schneller zum gewünschten System zugelagen habe ich hier Links gesetzt.

 Windows 7 | Windows Server 2012 / R2 | Übericht der Active Directory cmdlets

Zielstellung. Ebenso werden die cmdlets für Group Policies mit installiert. Unter Windows 7 und Windows Server 2012 / R2 werden die Group Policy cmdlets automatisch mit installiert.

ActiveDirectory cmdlets und GroupPolicy cmdlets

Active Directory cmdlets für Windows 7

Unter Systemsteuerung\Alle Systemsteuerungselemente\Programme und Funktionen auf Windows-Funktionen aktivieren oder deaktivieren klicken.

Windows-Funktionen aktivieren oder deaktivieren

Zum Öffnen und Installieren von Windows-Funktionen sind administrative Rechte nötig.

Unter Windows Funktionen navigieren wir nun zu Remoteserver-Verwaltungstools\Rollenverwaltungstools\AD DS-/ AD LDS-Tools. Dort wird der Haken bei  Active Directory-Modul für Windows PowerShell gesetzt. Dies installiert die Active Directory und Group Policy cmdlets. Der Haken bei AD LDS-Snap-ins und Befehlenzeilentools muss nicht wie in meinem Beispiel angehakt werden.

Windows-Funktionen aktivieren oder deaktivieren

Die Installation nimmt einen Augenblick in Anspruch.

Installation ActiveDirectory cmdlets und GroupPolicy cmdlets

Anschließend sollten die cmdlets in der PowerShell Console als auch in der PowerShell ISE zur Verfügung stehen. Ein Neustart des Clients ist i.d.R. nicht nötig. Fall die cmdlets in der aktiven Session nicht zur Verfügung stehen sollten, können diese einfach mittels dem Befehl import-module geladen werden

Das war‘s zu Windows 7. Hier noch eine Liste der verfügbaren cmdlets von Active Directory. Diese gelten für Windows 7 sowie Windows Server 2012 / R2. Weiter zu Windows 7 | Windows Server 2012 / R2 | Übericht der Active Directory cmdlets

Übersicht der Active Directory cmdlets

 

Active Directory cmdlets für Windows Server 2012 / R2

Die Aktivierung der Active Directory cmdlets erfolgt über den Windows Server Manager. In dem Manager auf Add roles and features klicken. Ich habe die Installation auf einem englischen System installiert, daher sind die Screenshots in Englisch.

Windows Server Manager

Es öffnet sich der Standardassistent. Wer die Haken bei Skip this page by default noch nicht gesetzt hat, landet zuerst auf der Befor You Begin Seite. Weiter mit Next.

Befor You Begin

Als Installation Type lassen wir die Einstellung bei Role-based or feature-based installation und klicken weiter mit Next.

Role-based or feature-based installation

Wir entscheiden uns für Select a server from the server pool und nehmen den Server auf dem wir die cmdlets installieren wollen. Optimal ist der aktuelle Server bereits ausgewählt. Weiter mit Next.

Select a server from the server pool

Bei Server Roles wählen wir Active Directory Lightweight Directory Services aus. Da die cmdlets als Role durchgehen.

Server Roles – Active Directory Lightweight Directory Services

Es öffnet sich ein Wizard, hier bestätigen wir das hinzufügen der folgenden Tools Active Directory-Modul für Windows PowerShell und AD LDS-Snap-ins und Befehlenzeilentools mit den Button Add Features.

Server Roles – Active Directory Lightweight Directory Services – Wizard

Anschließend bei Features auf Next kicken. Hier werden keine Änderungen vorgenommen.

Features

 Ebenso bei AD LDS auf Next klicken.

AD LDS

Anschließend gibt es eine Zusammenfassung der zu installierenden Roles und Features. Der Haken bei Restart the destination server automatically if requred muss nicht gesetzt werden. Auf Install klicken.

Confirmation

Das Installationsfenster kann geschlossen werden. Die Installation läuft im Hintergrund. Im Server Manager oben rechts werden wir über den aktuellen Status informiert.

ActiveDirectory cmdlets und GroupPolicy cmdlets

Die Installation ist angeschlossen und die cmdlets für Active Directory und Group Policies können genutzt werden.

Windows 7 | Windows Server 2012 / R2 | Übericht der Active Directory cmdlets

 

rewe

PowerShell – Games 01 – Galgenraten / Hangman

Save page

Nachdem ich es seit längerem nicht mehr geschafft habe meine bereits angefangenen Artikel zu veröffentlichen (dies leider aus Zeitgründen), hier mal etwas Neues aus der Kategorie ‚Spiele unter PowerShell‘. Um zu zeigen das mit PowerShell auch mehr als nur einfache Abfragen gegen das AD generiert werden können, habe ich hier ein Galgenraten, nicht grafischer Art, geschrieben. Dieses PS Script dient mir als Vorlage für die spätere Version in C#. Gerne kann auch über die Umsetzung und Effizienz des Codes diskutiert werden. Vielleicht gibt es einen besseren oder schöneren Weg? Aber nun erst mal zu meinem Code.

Welche Funktionen und Tools werden seitens PowerShell benötigt?

Grundsätzlich habe ich hier nur Funktionen auf Basis von PowerShell 3.0 genutzt. Dennoch sollte das Script ebenso mit PowerShell 2.0 funktionieren. Auf zusätzliche Cmdleds habe ich gänzlich verzichtet. Folgende Funktionen eines Strings habe ich genutzt:

  • ToUpper()1
  • Contains()1
  • Split()2
  • Replace()2
  • Remove()2
  • ToString()3

1 Diese Funktionen habe ich im Artikel PowerShell – 03.2 – Strings bearbeiten und untersuchen mit […] beschrieben.
2 Die Funktionen zum Bearbeiten eines Strings wurden im Artikel PowerShell – 03 – Strings zerlegen, zuschneiden, Teile ausschneiden, verbinden beschrieben.
3 toString() wandelt einen beispielsweise eine Integer in einen String um.

Es wurden auch Functions (PowerShell – 11 – Funktionen (Functions)) genutzt um zum einen das Script etwas übersichtlicher zu halten und damit sie die Abfrage nach dem Buchstaben wieder selbst aufrunden kann. Sicher hätte das auch mittels Do While Schleifen funktioniert. In meinem Falle reicht aber auch ein einfacher Funktionsaufruf.

Um die Anzahl der Versuche für ein Wort zu generieren habe ich mich einer einfachen Formel (0.3 * Wortlänge) bedient. Da dies zu Gleitkommazahlen führt, muss die Zahlen noch gerundet werden. Dafür nutzte ich die Mathefunktion Round. Dabei wird auf Ganzzahlen gerundet. Anschließend wird geprüft ob der ermittelte Wert unter 4 liegt, dann wird das Ergebnis von 4 Abgezogen und der Überhang anschließend auf die Anzahl der Versuche geschlagen, sodass der Spieler mindestens 4 Versuche pro Wort hat. Um dieses Wirre Kauderwelsch etwas verständlicher zu machen, hier der erste Code-Schnipsel.

Anschließend muss das gesucht Wort, hier im Beispiel soll es PowerShell sein, noch in die für den Spieler gesuchte Form P_________ gebracht werden. Ziel ist es das der Anfangsbuchstabe stehen bleibt, sollte dieser nochmals im Wort vorkommen, soll dieser natürlich auch stehen bleiben, z.B. bei Einkaufszentrum muss das E immer stehen bleiben, also wie folgt E________e____. Dazu wird eine temporäre Variable $Wort_tmp benötigt und eine einfache For-Schleife. Zuerst wird die temporäre Variable dem Wort gleichgesetzt $Wort_tmp = $Wort. In der For-Schleife wird nun geprüft ob der Anfangsbuchstabe nochmals vorkommt.

Ist dies der Fall so wird der aktuelle Wert in der Variable $Wort_tmp durch den Anfangsbuchstaben ersetzt, ist dies jedoch nicht der Fall wird das aktuelle Feld nur ein Unterstrich „_“ ersetzt. Sodas am Ende die Variable $Wort_tmp wie folgt aussieht: P_________.

Ein weiteres Problem war einen Weg zu finden den richtig getippten Buchstaben im Wort korrekt einzusetzen, wenn das Wort wie in unserem Beispiel PowerShell heißt, sieht es für den Spieler wie folgt nun aus P_________. Tippt dieser auf L und mach möchte mit der Funktion Replace() des Strings arbeiten werden alle ‚_‚ durch L ersetzt. Hier musste ich etwas tricksen, dazu habe ich zwei temporäre Variablen genommen.  Tippt der Spieler nun L ein wird nachfolgende Schleife durchlaufen, wenn L im Wort vorhanden ist.

Zuerst wird geprüft ob der gesuchte Buchstabe L enthalten ist, die Zeile dazu:

Ist diese Prüfung wahr, wird ermittelt wie oft der Buchstabe L sich im Wort PowerShell befindet. Die Übereinstimmungen werden in der Variable $Treffer gespeichert.  Leider reicht es hier nicht einfach nur einen Counter hochzählen zulassen, ich benötige die exakte Stelle im Wort PowerShell. Dazu nutze ich eine For-Schleife mit der ich jeden einzelnen Buchstaben mit Wort mit dem gesuchten Buchstaben L vergleiche. Ist diese Prüfung wahr, wird die Variable $Treffer mit dem Wert von $i und einem Semikolon erweitert. Warum jetzt $i? Ganz einfach, $i ist exakt der Wert des Buchstaben im Wort. In Unserem Beispiel ist dies einmal 8 und 9. Position 8 und 9 weil Arrays immer mit 0 Anfangen zu zählen. Anschließend Splitten wir die Variable $Treffer in ein Array und entfernen zuvor das letzte Semikolon. Somit haben wir die genaue Anzahl der Übereinstimmungen und die exakte Position der Buchstaben ermittelt. Dazu dient folgender Code-Schnipsel

Nun müssen wir die Übereinstimmungen noch in das Wort P_________ rein basteln. Dazu benötigen wir die eben ermittelte Anzahl von L und die exakten Positionen sowie zwei temporäre Variablen, einen Counter und eine For-Schleife. Die Variable $Wort_tmp2 wird der Wert von der bereits oben beschriebenen Variable $Wort_tmp übergeben. Dies geschieht aber nicht einfach als $Wort_tmp2 = $Wort_tmp, sonder $Wort_tmp2 = $Wort_tmp[0..$Wort_tmp.Lenth]. Was soll das bedeuten? Ganz einfach, hier wird nicht der String als String übergeben, sondern $Wort_tmp2 wird zu einem Array. So können wir jedes einzelne Feld prüfen und bei einer Übereinstimmung den gesuchten Buchstaben ersetzen. Die zweite temporäre Variable ist $Ausgabe_tmp, diese bildet anschließend die neu gebildete Ausgabe P_______LL. In der For-Schleife passiert dazu folgendes, der aktuelle Wert der Variable $Wort_tmp2 wird immer mit dem Wert von $Treffer_tmp[$j] verglichen. Passt dieser wird der Variable $Ausgabe_tmp der gesuchte Buchstaben, hier  L, hinzugefügt. Gibt es keine Übereinstimmung so wird der Counter $j um eins erhöht und es wird der Wert von $Wort_tmp2 abgehangen, was dann ein Unterstrich „_“ ist. So wird aus dem Array $Wort_tmp2 und dem einzelnen $Buchstaben wieder ein String $Ausgabe_tmp.

Anschließend muss das Ergebnis noch in der Console ausgegeben werden. Ist der gewählte $Buchstabe im Wort, so wird die oben genannte Schleife durchlaufen und es wird kein Lebenspunkt abgezogen. Ist dies nicht der Falle würde die Schleife nicht durchlaufen und gleich das Ergebnis präsentiert werden und natürlich ein Lebenspunkt abgezogen.

Kein Treffer

Nachdem dies geschehen ist, muss geprüft werden ob die Lebenspunkte bei 0 angekommen sind, ist dies der Fall so wird das Spiel mit einer entsprechenden Meldung und dem Exit-Command beendet.

Gehängt

Ebenso muss der gewählte Buchstabe aus dem vorgegebenen ABC entfernt werden, da dieser bereist verwendet wurde.

Um nun den nächsten Buchstaben erraten zu können wird geprüft ob unser Wort $Wort_tmp noch das Zeichen ‚_‘ enthält. Ist der Unterstrich noch enthalten, so gilt das Wort als noch nicht gelöst und die Hauptfunktion Game wird erneut aufgerufen, andern Falls wird die Funktion nicht mehr aufgerufen und eine Meldung „Du hast es geschafft“ ausgegeben und das Spiel ist erfolgreich beendet.

Erfolgreich gelöst

Soweit das Spiel in seinem Grundkonzept. Jetzt kommen wir zu dem wesentlich schwierigeren Teil: Fehler abfangen und das Ganze DAU-sicher machen.

Fehler abfangen und etwas Kosmetik

Was würdet ihr tun, wenn ihr eine solche Consolen-Anwendung vor die Nase gesetzt bekommt? Genau, erstmals kurz stauen und dann so schnell wie möglich alles versuchen damit das Teil abstürzt und bloß nicht das machen was die Anwendung von mir will. Um die Anfälligkeit der Anwendung gegen solche Versuche etwas zu minimieren habe ich folgendes unternommen.

Prüfen der Inputliste

Als erstes wird geprüft, ob die Wörterliste geladen werden kann. Dies läuft in einer Funktion, da diese sich wieder selbst aufrufen, sollte die Liste nicht erreichbar sein. Das Ganze ist einfach mittels Try-Catch realisiert. Es wird einfach versucht die angegebene Liste mittels Get-Content zu laden, schlägt dies Fehl springt das Script in den Catch-Fall und bittet den Benutzer mittels Read-Host den korrekten Pfad zur Wortliste anzugeben. Dieser Vorgang wird solange widerholt, bis entweder die Liste erreichbar ist oder der Benutzer ‚exit‘ eingibt. In diesem Falle wird das Script beendet. Ist dieser Schritt geschafft geht es auch schon daran die Eingabe des Spielers zu überwachen.

Inputliste laden

 Prüfen der eingabe

Geprüft wird die Eingabe. Hier habe ich die Länge der Eingabe auf 1 Zeichen beschränkt zudem dürfen Sonderzeichen wie +,*,\,/,$ etc. nicht enthalten sein, diese wird alles in die If-Abfrage gepackt.

Eingabe des Buchstaben

Geprüft werden muss auch, ob der gewählte Buchstabe noch im vorgegebenen Alphabet  $ABC vorhanden ist. Ist der Buchstabe nicht mehr enthalten, so wird eine Ausgabe erzeugt, die den Spieler auffordert einen anderen Buchstaben einzugeben.

Bereits verwendet

Noch etwas kosmetik

Damit die Ausgabe der Console nicht in einem Farblosen Schriftberg untergeht, habe ich hier mittels der Eigenschaften von Write-Host etwas Farbe rein gebracht.
Das Script könnt ihr euch hier nochmal im Ganzen anschauen. Ebenso könnt ihr es hier downloaden mit meiner äußerst kreativen Wortliste ;). Dann bitte einfach noch den String  $WortPfad anpassen.

Wer noch Ideen, Anregungen oder Fragen zum Code hat oder Verbesserungen sieht, darf sich gerne melden 🙂

Galgenraten
Galgenraten
sr_Galgenraten_release10_18042014Rzip.zip
Version: 1.0
2.4 KiB
434 Downloads
Details...

rewe

Script komplett, leider musste ich die Formatierung etwas anpassen, da der Interpreter hier sonst etwas Murks macht.