SHSpeech Recognition v.1.

4
customization tutorial
von MiTon

I. empfohlene Links und Programme die du

wahrscheinlich brauchen wirst:

II. get ready

III. customization - wie mache ich das?

A.wie funktioniert die Sprachersteuerung?

B.SHSPeech_Grammar.xml

C.SHSpeech_Commands.xml

D.Speech Recognition.py

IV.jetzt wird getestet

SHSpeech Recognition v.1.4 -
customization tutorial
von MiTon

Hallo da draußen!

Vermisst Du auch ein paar Befehle bei„Sprachsteuerung für

SH5“?
Warum nicht selber machen? So schwer istʻs nicht!

I. empfohlene Links und Programme die du

wahrscheinlich brauchen wirst:

A. JSGME (Mod Enabler)

B. Einen Editor wie notepad++, am besten mit installierten Plugins für Vergleich
und XML

C. DEVELOPING in „C:\Users\YourUserName\Documents\SH5\data\cfg
\main.cfg“. „eingeschaltet“

;COMMENT
[DEVELOPING]
Modding=Yes
MenuEditor=Yes
DebugScripts=Yes

D. Dazu auch [TEC] Mod Tools, HowTo! Wir werden den ScriptManager noch
zum testen benötigen!
II. get ready:

A. Wenn nicht so wieso schon passiert bitte JSGME installieren! Der Mod kommt
einfach wie sonst auch in den MODS Ordner. Ein super Ort um das ganze
dann auch schnell zu testen

B. Öffne MODS\Speech Recognition\data\Sound\Speech

\SHSpeech_Commands.xml mal im Browser.
C. Für den nächsten Schritt sollte notepad++ oder dein Lieblingseditor schon
bereit sein. Die Plugins für notepad++ kannst Du über Extras->PluginManager
ganz einfach installieren

D. Öffne MODS\Speech Recognition\data\Sound\Speech

\SHSpeech_Commands.xml und MODS\Speech Recognition\data\Sound
\Speech\SHSpeech_Grammar.xml in notepad++. Da wir mit zwei, bzw. drei
Dateien gleichzeitig arbeiten wollen, ist die Vergleichsansicht eine schicke
Sache

E. mit alt + 0 kann der code eingeklappt werden.

F. Wenn wir ihn nun schrittweise wieder entfalten ... wird das ganze auch
halbwegs übersichtlich. MODS\Speech Recognition\data\Scripts\Menu
\Speech Recognition.py habe ich inzwischen auch geladen
III. customization, wie mache ich das?
A.Wie funktioniert die Sprachsteuerung?
! Um die Befehle richtig zum Laufen zu bekommen, sollte man ungefähr
! wissen, wie die Speech Recognition Engine funktioniert:

1. SHSpeech_Grammar.xml: hier werden die Sätze oder Phrasen definiert die

von der Engine erkannt werden. In SHSpeech_Commands.xml bastelt man
aus diesen dann Befehle und ordnet sie bestimmten Kommandos zu. Das
können welche aus \Documentation\Game_Commands.pdf, oder selbst
erstellte Kommandos sein.

2. \Scripts\Menu\Speech_Recognition.py schaut nun nach den Kommandos,

die wir zuvor definiert haben und kümmert sich um solche die einer
Spezialbehandlunug bedürfen. Wie z.B. „Set_TDC_bearing“. Das wird dann
alles in Python erledigt. VORSICHT! in .py Dateien muss das mit dem
Einrücken genau stimmen!

B.SHSPeech_Grammar.xml

1. Wo finde ich die Datei überhaupt?

! ! \data\Sound\Speech\SHSpeech_Grammar.xml

2. Los gehts

Angenommen wir wollen einen Befehl einführen welcher es möglich

macht das verbesserte Erkennungshandbuch ein- und
auszublenden.Was müssen wir dafür tun?
Wir müssen dafür sorgen, das die Sätze, die später von der
Spracherkennung als Befehl erkannt werden sollen, in der Grammatik
vorhanden sind.
Dazu eine kleine Vorüberlegung. Was genau wollen wir den sagen um
diesen Sprachbefehl auszuführen?

z.B:
• Erkennungshandbuch einblenden
• Handbuch einblenden
• Handbuch anzeigen
• Handbuch wegpacken

All diese Befehl sollen später das Handbuch ein und ausblenden.
Aber vielleicht wollen wir ja später auch noch andere Dinge ein und
ausblenden deshalb sollten wir z.B. einblenden, ausblenden, anzeigen,
wegpacken, ... so verpacken, das wir es in der Grammatikdatei nicht
allzu oft tippen müssen?
Das gleiche gilt dann natürlich auch für Erkennungshandbuch,
Handbuch, ... Dabei sollten wir vielleicht auch noch daran denken ob die
Spracherkennung dieses Wort gut verstehen kann. Also fügen wir
vielleicht noch etwas wie Erkennungs Handbuch hinzufügen. Das
können wir dann später testen und gegebenenfalls einfach wieder
löschen.

Wir wollen diese Wörter quasi als Variable ablegen, dazu wird der Block

<rule id="idname"/></rule>

verwendet.

<one-of>
! <item>Erkennungshandbuch</item>
! <item>Handbuch</item>
! ! ....
<one-of>

die Regel enthält mehrere Elemente (<one-of></one-of>) mit dem Wert

(<item></item>)

Diese können wir nun in der Grammatikdatei statt eines Elements

werwenden.

<ruleref uri =“#idname“/>

der <rule>-Teil sollte dann in etwa so aussehen:

<rule id="toggle"/>
! <one-of>
! ! <item>einblenden</item>
! ! <item>anzeigen</item>
! ! <item>zeigen</item>
! ! <item>öffnen</item>
! !
! ! <item>ausblenden</item>
! ! <item>verbergen</item>
! ! <item>verstecken</item>
! ! <item>wegpacken</item>
! ! <item>schliessen</item>
! <one-of>
</rule>
<rule id="toggleable_items"/>
! <one-of>
! ! <item>Erkennungshandbuch</item>
! ! <item>Erkennungs Handbuch</item>
! ! <item>Handbuch</item>
! ! <item>Kriegstagebuch</item>
! ! <item>Bootsstatus</item>
! <one-of>
</rule>

Der Teil wo die Befehle „zusammengebaut“ werden:

<!--Ich bin ein Kommentar-->

<!--hier wird nun das Kommando definiert-->
<rule id="command" scope="public“/>
! <one-of>
! ! <!--Hier definieren wir unsere Befehle-->
! ! <item><!--toggle toggleable_items-->
! ! ! <ruleref id="#toggleable_items"/><!-- # -->
! ! ! <ruleref id="#toggle"/>
! ! </item>

<!-- Hier gehts eigentlich noch viel weiter-->

!
So, wollen wir nun irgendetwas ein- oder ausblenden haben wir nun die
Möglichkeit das einfach als neues <item> in die Regel einzufügen und
es ist automatisch immer dabei wenn die entsprechende <ruleref uri>
aufgerufen wird. Hier immer auf das # achten.
Wir können uns aber auch einen neuen Befehl basteln z.B.

<!--Ich bin ein Kommentar-->

<!--hier wird nun das Kommando definiert-->
<rule id="command" scope="public“/>
! <one-of>
! ! <--!Hier definieren wir unsere Befehle-->
! ! <item><!--toggle toggleable_items-->
! ! ! <ruleref id="#toggleable_items"/><!-- # -->
! ! ! <ruleref id="#toggle"/>
! ! </item>

! ! <item><!--ein neuer Befehl-->

! ! ! <item>Uhrzeit</item>
! ! ! <ruleref id="#toggle"/>
! ! ! <item repeat="0-1"/>
! ! ! ! <one-of>
! ! ! ! ! <item>1WO</item>
! ! ! ! ! <item>LI</item>
! ! ! ! </one-of>
! ! ! </item>
! ! </item>

Jetzt können wir also auch die Uhr ein- und ausblenden.
Z.B. mit „ Uhrzeig anzeigen LI“, oder aber auch nur „Uhrzeit
einblenden“.
Wiederholungen und das gilt auch für die Möglichkeit das Wort nur
vielleicht zu benutzen, erledigen wir wie gesehen über <item
repeat=“0-1“>.
Das heisst „0-1“ gibt mir die Möglichkeit das Wort wegzulassen.
„3“ bedeutet das ich das Wort 3mal wiederholen muss.
 ich definiere also z.B.

<item repeat="2-3"/><!--Alarmtauchen-->
! tauchen
</item>

und ich habe „tauchen tauchen“ sowie „tauchen tauchen tauchen“ in

der Grammatik definiert.

3. Wie gehtʻs weiter?

Die Arbeit in SHSpeech_Grammar ist nun getan, wir lassen sie aber
noch geöffnet, da wir sie noch zum spicken verwenden werden.
 C.SHSpeech_Commands.xml

1. Wo finde ich die Datei überhaupt?

! ! \data\Sound\Speech\SHSpeech_Grammar.xml
In dieser Datei dreht sich alles um <order></order>, <phrase></phrase> und
<commandText></commandText>.
<order></order> ist quasi der Container und fasst die einzelnen Sätze
( <phrase></phrase>) die wir in der Grammatikdatei definiert haben für einen
Befehl zusammen und kombiniert diesen mit dem entsprechenden
Kommando (<commandText></commandText>).
<commandText> wird dann von Speech Recognition.py weiterverarbeitet aber
dazu später mehr.

Wir haben zuvor neue Sätze definiert, diese wollen wir nun noch an ein
Kommando binden:

2. Wir bauen uns einen neuen leeren Befehl „Erkennungshandbuch

einblenden

<order><!--Erkennungshandbuch einblenden-->

! <commandText></commandText>
</order>

a) füllen ihn mit den entsprechenden Informationen aus der Grammatik

Datei, die wir dafür benötigen. In unserem Fall die Elemente von <rule
id=“toggleable_items“> und „toggle“.

<order><!--Erkennungshandbuch einblenden-->
! <item>Erkennungshandbuch</item>
! <item>Erkennungs Handbuch</item>
! <item>Handbuch</item>

! <item>einblenden</item>
! <item>anzeigen</item>
! <item>zeigen</item>
! <item>öffnen</item>

! <commandText></commandText>
</order>
3. Mit etwas Überlegung und Copy and Paste können wir daraus im nu eine
ganze Latte an <phrase> basteln. Wir kopieren uns dazu einfach mal
„Erkennungshandbuch“ vor die Elemente „einblenden“.

<order><!--Erkennungshandbuch einblenden-->
! <item>Erkennungshandbuch</item>
! <item>Erkennungs Handbuch</item>
! <item>Handbuch</item>

! <item>Erkennungshandbuch</item><item>einblenden</item>
! <item>Erkennungshandbuch</item><item>anzeigen</item>
! <item>Erkennungshandbuch</item><item>zeigen</item>
! <item>Erkennungshandbuch</item><item>öffnen</item>

! <commandText></commandText>
</order>

Dann kopieren den neuen Block einfach so oft wir noch andere <item>
aus der Gruppe „#toggleable_items“ haben. In diesem fall also zweimal.
In den Zwei Kopien ersetzen wir dann einfach Erkennungshandbuch,
Erkennungs Handbuch und Handbuch.
Wenn wir dann noch ein bißchen aufräumen bekommen wir

<order><!--Erkennungshandbuch einblenden-->
! <item>Erkennungshandbuch</item><item>einblenden</item>
! <item>Erkennungshandbuch</item><item>anzeigen</item>
! <item>Erkennungshandbuch</item><item>zeigen</item>
! <item>Erkennungshandbuch</item><item>öffnen</item>
!
! <item>Erkennungs Handbuch</item><item>einblenden</item>
! <item>Erkennungs Handbuch</item><item>anzeigen</item>
! <item>Erkennungs Handbuch</item><item>zeigen</item>
! <item>Erkennungs Handbuch</item><item>öffnen</item>

! <item>Handbuch</item><item>einblenden</item>
! <item>Handbuch</item><item>anzeigen</item>
! <item>Handbuch</item><item>zeigen</item>
! <item>Handbuch</item><item>öffnen</item>

! <commandText></commandText>
</order>
4. Nun ersetzen wir </item><item> erst einmal durch ein Leerzeichen. Und im
Anschluss item durch phrase und wir sind fast fertig

<order><!--Erkennungshandbuch einblenden-->
! <phrase>Erkennungshandbuch einblenden</phrase>
! <phrase>Erkennungshandbuch anzeigen</phrase>
! <phrase>Erkennungshandbuch zeigen</phrase>
! <phrase>Erkennungshandbuch öffnen</phrase>
!
! <phrase>Erkennungs Handbuch einblenden</phrase>
! <phrase>Erkennungs Handbuch anzeigen</phrase>
! <phrase>Erkennungs Handbuch zeigen</phrase>
! <phrase>Erkennungs Handbuch öffnen</phrase>

! <phrase>Handbuch einblenden</phrase>
! <phrase>Handbuch anzeigen</phrase>
! <phrase>Handbuch zeigen</phrase>
! <phrase>Handbuch öffnen</phrase>

! <commandText></commandText>
</order>

5. Jetzt müssen wir noch irgendwie die Lücke füllen die in <commandText></
commandText> vorhanden ist. Dazu können wir Befehle verwenden, die
unter \Documentation\Game_Commands.txt aufgeführt sind und auch in
bei der Tastaturbelegung zum Einsatz kommen können. Da aber nicht alle
Befehle auch so funktionieren oder evtl. gar nicht vorhanden sind, kommt
die Speech Recognition.py zum Einstaz.
D.Speech Recognition.py

1. Wo finde ich die Datei überhaupt?

\data\Scripts\Menu\SHSpeech_Grammar.xml

2. Hier findest du dann in etwa sowas

#This is just a comment

# new command "Enhanced_RM_visible" blendet das Erkennungs-
handbuch ein
elif cmd == "Enhanced_RM_visible":

Wichtig dabei ist die Zeile elif cmd == "Enhanced_RM_visible":

Der Befehl den wir suchen ist also Enhanced_RM_visible.

3. Den gefunden Befehl fügen wir nun in SHSpeech_Commands.xml bei

unserem zuvor neu erstellten Befehl unter <commandText></commandText>
ein.

<order><!--Erkennungshandbuch einblenden-->
! <phrase>Erkennungshandbuch einblenden</phrase>
! <phrase>Erkennungshandbuch anzeigen</phrase>
! <phrase>Erkennungshandbuch zeigen</phrase>
! <phrase>Erkennungshandbuch öffnen</phrase>
!
! <phrase>Erkennungs Handbuch einblenden</phrase>
! <phrase>Erkennungs Handbuch anzeigen</phrase>
! <phrase>Erkennungs Handbuch zeigen</phrase>
! <phrase>Erkennungs Handbuch öffnen</phrase>

! <phrase>Handbuch einblenden</phrase>
! <phrase>Handbuch anzeigen</phrase>
! <phrase>Handbuch zeigen</phrase>
! <phrase>Handbuch öffnen</phrase>

! <commandText> Enhanced_RM_visible </commandText>

</order>

Fertig! In dieser Art können wir nun weitere Befehle hinzufügen oder
verändern.
Wenn wir testen wollen, weiter zu Abschnitt IV.
! Das wäre evtl. ein guter Zeitpunkt für ein Backup :)
IV.jetzt wird getestet:
A. Installieren wir erst einmal unseren Mod.

B. Dann starten wir SHSpeechEngineTest.exe, die sich im „SH5“ Ordner

befindet. Sieht so aus, als ob wir alles richtig gemacht haben, keine
Fehlermeldung zu sehen.
C. Nun können wir schon testen ob die Spracherkennung den neuen Befehl
erkennt und auch einen Kommando ausführt:

erkannter Sprachbefehl: Kommando das an .py übergeben wird: Parameter1,

Parameter2

Mit „confidence“-Level wirst Du wahrscheinlich etwas spielen müssen.

Ist einpassender Wert gefunden muss er in Speech_Recognition.py
eingetragen werden. Halte Ausschau nach:

if speech == None:
! speech = SHSpeechEngine("en-US")
! speech.Confidence = 0.70 # This is the default and could be ommited!

D. und ändere den Wert dementsprechend. WICHTIG! Kein Komma sondern

einen Punkt für die Kommastellen verwenden.
E. So, Silent Hunter 5 wird gestartet, aber ohne MenuEditor!

F. Nach dem Synchronisieren können wir den SkriptManager, wie hier

beschrieben starten. [TEC] Mod Tools, HowTo

G. Auf der linken Seite finden wir nun Menu

H. weiter und wir finden Speech Recognition.py:

 I. Um nun noch weiter Kommands hinzuzufügen und gleich zu testen,
speichern wir die neuen Dateien ab, schliesse die SHSpeechEngineTest.exe,
deaktiviere und aktivieren den Mod und starten SHSpeechEngineTest.exe neu
Wenn das geschafft ist im SkriptManager einfach in einer leeren Zeile enter
drücken und auf „Apply changes“ clicken.
! Das Spiel stoppt kurz und lädt die neuen Dateien!

Happy testing!