Lua-AKFAvatar Referenz(3)                            Lua-AKFAvatar Referenz(3)



NNAAMMEE
       Lua-AKFAvatar Referenz - AKFAvatar spezifische Funktionen für Lua

BBEESSCCHHRREEIIBBUUNNGG
       Dies  ist  eine  Referenz  für  die  Lua-Anbindung  für AKFAvatar.  Sie
       beschreibt nicht die Sprache  Lua.   Eine  Referenz-Anleitung  für  die
       Sprache  Lua  findet  man  im  Internet  unter  hhttttpp::////wwwwww..lluuaa..oorrgg//mmaann‐‐
       uuaall//55..22//, oder auf Deutsch unter hhttttpp::////lluuaa..ccooddeerrss--oonnlliinnee..nneett//.

       Keine Angst. Man muss nicht alles gleich  verstehen  oder  gar  lernen.
       Man kann schon eine ganze Menge mit nur ganz wenigen Befehlen anfangen.
       Einfach mal die Teile heraussuchen, die einen interessieren  und  damit
       herumexperimentieren.   Es  gibt  viele Aspekte von Lua oder AKFAvatar,
       die man wahrscheinlich nie benötigt.

   DDaatteeii--FFoorrmmaattee
       Für Bilder werden die Formate XXPPMM,  XXBBMM  und  unkomprimiertes  BBMMPP  auf
       jeden  Fall  unterstützt.   Weitere  Formate  werden  unterstützt, wenn
       SSDDLL__iimmaaggee und weitere Bibliotheken installiert sind.

       Für Audio werden die Formate AAUU und WWAAVV  unterstützt.   Dateien  können
       als  PCM,  μ-law  oder  A-law kodiert sein.  Es gibt auch ein Lua-Modul
       namens aakkffaavvaattaarr--vvoorrbbiiss, welches Unterstützung für  Ogg  Vorbis  Audio-
       Dateien hinzufügt.

   GGrruunnddffuunnkkttiioonnaalliittäätt
       llooccaall aavvtt == rreeqquuiirree ""lluuaa--aakkffaavvaattaarr""
              Bevor  man  die AKFAvatar-Anbindung verwenden kann, muss man sie
              mit dieser Anweisung erstmal laden.  Über die Tabelle  _a_v_t  kann
              man dann die folgenden Funktionen abrufen.

       aavvtt..eennccooddiinngg((_e_n_c_o_d_i_n_g))
              Legt die Text-Kodierung fest.  Wenn diese Funktion nicht verwen‐
              det wird, wird nur "ASCII" unterstützt.

              Unterstützte Kodierungen:
              ASCII, UTF-8,
              ISO-8859-1, -2, -3, -4, -5, -7, -8, -9, -10, -11, -13, -14, -15,
              -16,
              KOI8-R, KOI8-U,
              IBM437 (PC-8), IBM850 (DOS-Latin-1),
              WINDOWS-1250, WINDOWS-1251, WINDOWS-1252
              SYSTEM

       aavvtt..ggeett__eennccooddiinngg(())
              Fragt die Text-Kodierung ab.

       aavvtt..ttiittllee((_T_i_t_e_l _[_,_K_u_r_z_n_a_m_e_]))
       aavvtt..sseett__ttiittllee((_T_i_t_e_l _[_,_K_u_r_z_n_a_m_e_]))
              Legt den Titel und den Kurznamen fest.

       aavvtt..ssttaarrtt((_M_o_d_u_s))
              Diese Funktion öffnet das grafische Fenster oder wechselt in den
              Grafikmodus.  Falls es schon gestartet war, wird  vieles  zurück
              gesetzt.

              _M_o_d_u_s   ist   entweder   "auto",  "window",  "fullscreen",  oder
              "fullscreen no switch".   Die  Vorgabe  ist  "auto",  die  einen
              brauchbaren  Modus  verwendet,  oder die Einstellung unverändert
              lässt, wenn es bereits gestartet war.

              Wenn man die Kodierung, den  Titel  oder  die  Hintergrund-Farbe
              setzen  will,  sollte  man  es  machen,  bevor  man  aavvtt..ssttaarrtt(())
              aufruft.  Alle anderen Funktionen sollten erst danach  verwendet
              werden.

              BBeeiissppiieell::
              local avt = require "lua-akfavatar"
              avt.encoding("ISO-8859-1")
              avt.title("Mein Programm")
              avt.set_background_color("sky blue")
              avt.start()
              avt.start_audio()
              avt.avatar_image("default")
              avt.tell("Hallo Welt!")
              avt.wait_button()

              Viele  der  folgenden  Funktionen  rufen automatisch aavvtt..ssttaarrtt(())
              auf, wenn es noch nicht gestartet ist.

       aavvtt..ssttaarrtteedd(())
              Gibt _t_r_u_e zurück, wenn AKFAvatar bereits gestartet  ist,  anson‐
              sten gibt es _f_a_l_s_e zurück.

       aavvtt..aavvaattaarr__iimmaaggee((_D_a_t_e_n))
              Lädt  das  Avatar-Bild von den _D_a_t_e_n.  Die _D_a_t_e_n können entweder
              "default" oder "none" sein, oder ein String mit Bilddaten,  oder
              eine Tabelle mit Strings von XPM-Daten.

       aavvtt..aavvaattaarr__iimmaaggee__ffiillee((_D_a_t_e_i_n_a_m_e))
              Lädt  das  Avatar-Bild  aus  einer Datei.  Die Strings "default"
              oder "none" werden auch akzeptiert.

       aavvtt..sseett__aavvaattaarr__nnaammee((_[_N_a_m_e_]))
              Setzt den Namen für den Avatar.  Dies muss nach dem  Setzen  des
              Bildes geschehen.

       aavvtt..sseett__aavvaattaarr__mmooddee((_M_o_d_u_s))
              Legt  den  Avatar-Modus  fest.   Der  _M_o_d_u_s  ist  entweder "say"
              (sagen), "think" (denken), "header" (Überschrift) oder  "footer"
              (Fußzeile).   Der  Avatar-Modus  wird  nur  angewandt,  wenn ein
              Avatar-Bild vorhanden ist.

       aavvtt..ssaayy((_._._.))
       aavvtt..wwrriittee((_._._.))
              Schreibt Text in der Sprechblase.

              Man kann Strings oder  Zahlen  verwenden.   Es  funktioniert  so
              ähnlich wie iioo..wwrriittee(()), aber es schreibt halt in die Sprechblase
              anstatt auf die Standardausgabe.

              BBeeiissppiieell::
              avt.say("Drei Äpfel kosten ", 3 * Apfelpreis, " Euro.\n").

       aavvtt..pprriinntt((_._._.))
              Schreibt Text in der Sprechblase.  Es  funktioniert  so  ähnlich
              wie  pprriinntt, aber es schreibt halt in die Sprechblase anstatt auf
              die Standardausgabe.

              Der Unterschied zu aavvtt..ssaayy(()) ist, dass die Werte in der  Ausgabe
              durch  Tabulatoren  getrennt  werden  und jeder Wert automatisch
              durch ttoossttrriinngg(()) umgewandelt wird. Außerdem wird die Zeile durch
              einen Zeilenumbruch abgeschlossen.

              Mann  kann  einfach den print-Befehl mit diesem Befehl ersetzen:
              pprriinntt == aavvtt..pprriinntt.  (Das Skript `interactive_lua.lua' macht  das
              so.)

              Die Funktion aavvtt..ssaayy(()) eignet sich besser für Programme, während
              diese Funktion besser für die interaktive Verwendung  und  für's
              Debuggen geeignet ist.

       aavvtt..tteellll((_._._.))
              Schreibt  Text in der Sprechblase, aber zuvor wird die Größe der
              Sprechblase angepasst, so dass der Text exakt reinpasst.

              BBeeiissppiieell::
              avt.tell("Drei Äpfel kosten ", 3 * Apfelpreis, " Euro.").

              AAcchhttuunngg:: Diese Funktion hat noch immer Probleme mit  Tabulatoren
              ("\t").

       aavvtt..nneewwlliinnee(())
              Beginne eine neue Zeile.  Das selbe, wie "\n" in aavvtt..ssaayy(()), aber
              schneller.

       aavvtt..sseett__tteexxtt__ddeellaayy((_[_V_e_r_z_ö_g_e_r_u_n_g_]))
              Aktiviere  den  Langsamschreibmodus.   Wenn  _V_e_r_z_ö_g_e_r_u_n_g   nicht
              angegeben  ist, wird ein Vorgabewert verwendet.  Um den Langsam‐
              schreibmodus zu  daktivieren,  kann  man  den  Wert  0  für  die
              _V_e_r_z_ö_g_e_r_u_n_g verwenden.

       aavvtt..cclleeaarr(())
              Löscht  das Text-Feld oder den Bereich.  Wenn noch keine Sprech‐
              blase angezeigt wird, wird diese hierdurch gezeichnet.

       aavvtt..fflliipp__ppaaggee(())
              Wartet eine Weile und löscht dann das Text-Feld.  Dasselbe  wird
              durch     "\f"    in    aavvtt..ssaayy(())    erreicht.     Siehe    auch
              aavvtt..sseett__fflliipp__ddeellaayy((ddeellaayy)).

       aavvtt..mmoovvee__iinn(())
              Bewegt den Avatar herein.

       aavvtt..mmoovvee__oouutt(())
              Bewegt den Avatar heraus.

       aavvtt..ppaaggeerr((_T_e_x_t _[_,_A_n_f_a_n_g_s_z_e_i_l_e_]))
              Zeigt einen längeren Text in einer Textbetrachter-Anwendung.

              Wenn die _A_n_f_a_n_g_s_z_e_i_l_e angegeben und größer als 1 ist, dann fängt
              er  in der Zeile an.  Man kann von da aus aber immer noch zurück
              scrollen.

       aavvtt..wwaaiitt((_[_S_e_k_u_n_d_e_n_]))
              Wartet eine angegebene Zeit an Sekunden (kann ein  Dezeimalbruch
              sein).

              Wenn kein Wert angegeben ist, wartet er eine gewisse Zeit.

       aavvtt..ttiicckkss(())
              Gibt  einen Wert zurück, der jede Millisekunde erhöht wird.  Das
              kann für Zeitsteuerung verwendet werden.

       aavvtt..sshhooww__aavvaattaarr(())
              Zeigt nur den Avatar ohne Sprechblase.

       aavvtt..bbeellll(())
              Gibt einen Ton aus, oder die Anzeige blinkt, wenn die Audio-Aus‐
              gabe nicht initialisiert ist.

       aavvtt..ffllaasshh(())
              Die Anzeige blinkt einmal.

       aavvtt..sshhooww__iimmaaggee((_D_a_t_e_n))
              Zeigt  ein  Bild von Bilddaten.  Die _D_a_t_e_n können ein String mit
              Bilddaten sein, oder eine Tabelle  mit  Strings  von  XPM-Daten.
              Bei  Erfolg  wird  _t_r_u_e zurückgegeben, oder _f_a_l_s_e im Fehlerfall.
              Bei Erfolg sollte  entweder  aavvtt..wwaaiitt(())  oder  aavvtt..wwaaiitt__bbuuttttoonn(())
              oder aavvtt..ggeett__kkeeyy(()) aufgerufen werden.

       aavvtt..sshhooww__iimmaaggee__ffiillee((_D_a_t_e_i_n_a_m_e))
              Lädt  ein  Bild und zeigt es an.  Man kann mit _a_v_t_._s_e_a_r_c_h_(_) nach
              der Datei suchen lassen.  Bei Erfolg  wird  _t_r_u_e  zurückgegeben,
              oder _f_a_l_s_e im Fehlerfall.  Bei Erfolg sollte entweder aavvtt..wwaaiitt(())
              oder aavvtt..wwaaiitt__bbuuttttoonn(()) oder aavvtt..ggeett__kkeeyy(()) aufgerufen werden.

       aavvtt..ssuubbpprrooggrraamm((_f_u_n_c_t_i_o_n_, _[_a_r_g_1_, _._._._]))
              Ruft die Funktion als Unterprogramm auf.

              Bei einer  Beendigungsanfrage  (dh.  wenn  man  die  <Esc>-Taste
              drückt,  oder  den  Schließ-Knopf des Fensters) kehrt es nur zum
              Hauptprogramm zurück.

              Bei Erfolg werden die  Ergebnisse  der  Funktion  zurückgegeben.
              Bei einer Beendigungsanfrage wird nichts zurückgegeben.

              Um  ein Unterprogramm aus einer separaten Datei zu starten, kann
              man ddooffiillee verwenden.
              avt.subprogram(dofile, "unterprogramm.lua")

       aavvtt..ooppttiioonnaall((_m_o_d_n_a_m_e))
              Lädt ein Modul wie rreeqquuiirree, aber das Modul wird nicht  benötigt,
              sondern  es  ist  optional.  Das heißt, es ist kein Fehler, wenn
              das Modul nicht geladen werden kann.

              Lua-AKFAvatar braucht nicht initialisiert sein, um  diese  Funk‐
              tion zu verwenden.

   UUnniiccooddee
       aavvtt..ssaayy__uunniiccooddee((_._._.))
              Schreibt  Text  in  der Sprechblase mit spezieller Unterstützung
              für Unicode-Zeichen.

              Dieser Befehl ist ähnlich wie aavvtt..ssaayy(()).  Strings werden auf die
              selbe Weise behandelt, abhängig von der eingestellten Kodierung,
              aber  Zahlen   werden   als   Unicode-Codepoint   interpretiert,
              unabhängig von der eingestellten Kodierung.

              Man  kann  das  verwenden,  um  Zeichen zu verwenden, die in der
              eingestellten Kodierung nicht zur  Verfügung  stehen.   Manchmal
              ist es aber auch einfach nur einfacher.

              BBeeiissppiieell::
              avt.say_unicode("Drei Äpfel kosten ",
                              tostring(3 * Apfelpreis), 0x20AC,
                              ".\n").

              Wie  man  hier  sieht,  muss man ttoossttrriinngg(()) verwenden, wenn num‐
              merische Angaben als solche angezeigt werden sollen.   Die  Zahl
              _0_x_2_0_A_C  hingegen  repräsentiert  hier  das Euro-Währungszeichen.
              (Das `0x' leitet hexadezimale Zahlen ein.)

              Übrigens werden eine Gruppe von Unicode-Zahlen effektiver verar‐
              beitet als Strings.

       aavvtt..pprriinnttaabbllee((_C_o_d_e_p_o_i_n_t))
              Überprüft  ob  der  angegebene _C_o_d_e_p_o_i_n_t ein druckbares Unicode-
              Zeichen darstellt.  Es gibt _t_r_u_e zurück, wenn das der Fall  ist,
              oder  _f_a_l_s_e,  wenn  die Schriftart kein druckbares Zeichen dafür
              hat (es kann trotzdem  ein  unterstütztes  Steuerzeichen  sein).
              Diese  Funktion  ist unabhängig von der eingestellten Kodierung.
              Sie kann zusammen mit aavvtt..ssaayy__uunniiccooddee((......))  eingesetzt werden.

       aavvtt..ccoommbbiinniinngg((_C_o_d_e_p_o_i_n_t))
              Überprüft ob der angegebene _C_o_d_e_p_o_i_n_t  ein  kombinierendes  Uni‐
              code-Zeichen  darstellt und als solches behandelt wird.  Es gibt
              _t_r_u_e zurück, wenn das der Fall ist, oder _f_a_l_s_e,  wenn  es  nicht
              als  solches  unterstützt  wird.   Das  Ergebnis  gilt  nur  für
              unterstützte Zeichen.

       aavvtt..ddeetteecctt__uuttff88((_S_t_r_i_n_g _[_, _M_a_x_i_m_a_l_l_ä_n_g_e_]))
              Prüft, of _S_t_r_i_n_g gültiges UTF-8 (oder ASCII) ist.

              Geprüft  werden   bis   zu   _M_a_x_i_m_a_l_l_ä_n_g_e   Bytes,   aber   eine
              unvollständige Sequenz wird noch abgeschlossen.

       aavvtt..ttoouuttff88((_C_o_d_e_p_o_i_n_t _[_, _._._._]))
              Nimmt  einen oder mehrere angegebene Unicode _C_o_d_e_p_o_i_n_t_s und gibt
              diese als UTF-8 kodierten String zurück.

       aavvtt..uuttff88ccooddeeppooiinnttss((_s_t_r))
              Kann verwendet werden, um  alle  Unicode  Codepoints  von  einem
              UTF-8 kodierten String als Zahlen zu erhalten.

              Beispiel:
                for c in avt.utf8codepoints(s) do
                  avt.say_unicode(c)
                  avt.say(string.format(" = U+%04X", c))
                  avt.newline()
                end

   GGrröößßeenn uunndd PPoossiittiioonneenn
       aavvtt..sseett__bbaalllloooonn__ssiizzee((_[_H_ö_h_e_] _[_, _B_r_e_i_t_e_]))
              Legt die Größe der Sprechblase fest.  Wenn keine Werte angegeben
              sind, oder der Wert 0 verwendet wird, wird  die  maximale  Größe
              verwendet.

       aavvtt..sseett__bbaalllloooonn__wwiiddtthh((_[_B_r_e_i_t_e_]))
              Legt  die  Breite der Sprechblase fest.  Ohne Wert, oder bei dem
              Wert 0 wird das Maximum verwendet.

       aavvtt..sseett__bbaalllloooonn__hheeiigghhtt((_[_H_ö_h_e_]))
              Legt die Höhe der Sprechblase fest.  Ohne  Wert,  oder  bei  dem
              Wert 0 wird das Maximum verwendet.

       aavvtt..ggeett__mmaaxx__xx(())
              Ermittelt  die maximale x-Postion des Cursors in der Sprechblase
              (also die Breite).

       aavvtt..ggeett__mmaaxx__yy(())
              Ermittelt die maximale y-Postion des Cursors in der  Sprechblase
              (also die Höhe).

       aavvtt..wwhheerree__xx(())
              Ermittelt die x-Position des Cursors in der Sprechblase.

       aavvtt..wwhheerree__yy(())
              Ermittelt die y-Position des Cursors in der Sprechblase.

       aavvtt..hhoommee__ppoossiittiioonn(())
              Gibt  _t_r_u_e  zurück,  wenn  sich der Cursor auf der Startposition
              befindet, oder _f_a_l_s_e, wenn nicht.  (Das  funktioniert  auch  für
              rechts-nach-links-Schreibung.)

       aavvtt..mmoovvee__xx((_x))
              Setzt den Curser auf die angegebene _x-Position.

       aavvtt..mmoovvee__yy((_y))
              Setzt den Curser auf die angegebene _y-Position.

       aavvtt..mmoovvee__xxyy((_x_, _y))
              Setzt den Curser auf die angegebene _x und _y Position.

       aavvtt..ssaavvee__ppoossiittiioonn(())
              Speichert die aktuelle Cursor-Position.

       aavvtt..rreessttoorree__ppoossiittiioonn(())
              Stellt eine zuvor gespeicherte Cursor-Postion wieder her.

       aavvtt..nneexxtt__ttaabb(())
              Setzt den Cursor auf die nächste Tabulator-Position.

       aavvtt..llaasstt__ttaabb(())
              Setzt den Cursor auf die vorhergehende Tabulator-Position.

       aavvtt..rreesseett__ttaabb__ssttooppss(())
              Setzt die Tabulator-Positionen zurück auf jede achte Spalte.

       aavvtt..cclleeaarr__ttaabb__ssttooppss(())
              Löscht alle Tabulator-Postionen

       aavvtt..sseett__ttaabb((_x_, _t_r_u_e||_f_a_l_s_e))
              Setzt oder löscht einen Tabulator an der angegebenen Position _x.

       aavvtt..ddeelleettee__lliinneess((_Z_e_i_l_e_, _A_n_z_a_h_l))
              Löscht  die  angegebene  _A_n_z_a_h_l an Zeilen, angefangen bei _Z_e_i_l_e;
              der Rest wird hochgescrollt.

       aavvtt..iinnsseerrtt__lliinneess((_Z_e_i_l_e_, _A_n_z_a_h_l))
              Fügt die angegebene _A_n_z_a_h_l an Zeilen ein, angefangen bei  _Z_e_i_l_e;
              der Rest wird runtergescrollt.

       aavvtt..iinnsseerrtt__ssppaacceess((_A_n_z_a_h_l))
              Fügt  _A_n_z_a_h_l  an  Leerzeichen bei der jetzigen Postion ein.  Der
              Rest der Zeile wird weiter gerückt.

       aavvtt..ddeelleettee__cchhaarraacctteerrss((_A_n_z_a_h_l))
              Löscht _A_n_z_a_h_l an Zeichen an der jetzigen  Cursor-Position.   Der
              Rest der Zeile wird zurück gerückt.

       aavvtt..eerraassee__cchhaarraacctteerrss((_A_n_z_a_h_l))
              Löscht  _A_n_z_a_h_l  an  Zeichen.  Die Zeichen werden mit Leerzeichen
              überschrieben.

       aavvtt..bbaacckkssppaaccee(())
              Geht ein Zeichen zurück.  Wenn der Cursor am  Anfang  der  Zeile
              ist, passiert nichts.

   TTeexxtt--SSttiill
       aavvtt..mmaarrkkuupp((_t_r_u_e||_f_a_l_s_e))
              Setzt  den Auszeichnungs-Modus.  Im Auszeichnungs-Modus schaltet
              das Zeichen "_" das Unterstreichen ein oder aus und das  Zeichen
              "*"  schaltet  den  Fettdruck-Modus  ein  oder  aus.  Die beiden
              Zeichen werden im Auszeichnungs-Modus niemals angezeigt!

              Man kann  immer  die  Overstrike-Technik  verwenden,  die  keine
              Zeichen reserviert.  Aber die ist schwerer zu benutzen.

       aavvtt..uunnddeerrlliinneedd((_t_r_u_e||_f_a_l_s_e))
              Schaltet das Unterstreichen ein oder aus.

       aavvtt..ggeett__uunnddeerrlliinneedd(())
              Gibt  _t_r_u_e  zurück,  wenn Unterstreichen eingeschaltet ist, oder
              _f_a_l_s_e, wenn nicht.

       aavvtt..bboolldd((_t_r_u_e||_f_a_l_s_e))
              Schaltet den Fettdruck an oder aus.

       aavvtt..ggeett__bboolldd(())
              Gibt _t_r_u_e zurück, wenn Fettdruck eingeschaltet ist, oder  _f_a_l_s_e,
              wenn nicht.

       aavvtt..iinnvveerrssee((_t_r_u_e||_f_a_l_s_e))
              Schaltet die invertierte Darstellung an oder aus.

       aavvtt..ggeett__iinnvveerrssee(())
              Gibt _t_r_u_e zurück, wenn die invertierte Darstellung eingeschaltet
              ist, oder _f_a_l_s_e, wenn nicht.

       aavvtt..nnoorrmmaall__tteexxtt(())
              Setzt normale Einstellungen für Text zurück.

   FFaarrbbeenn
       aavvtt..sseett__bbaacckkggrroouunndd__ccoolloorr((_F_a_r_b_e))
              Setzt die Hintergrundfarbe für den Bildschirm.

              Farben können entweder über  ihren  englischen  Namen  angegeben
              werden, oder als RGB-Angabe 6 hexadezimalen Ziffern.

              BBeeiissppiieellee::
              avt.set_background_color("sky blue")
              avt.set_background_color(0x8B4513)
              avt.set_background_color("#8B4513") --> nicht empfohlen
              avt.set_background_color("#555") --> nicht empfohlen

       aavvtt..sseett__bbaalllloooonn__ccoolloorr((_F_a_r_b_e))
              Setzt die Farbe der Sprechblase.

       aavvtt..sseett__tteexxtt__ccoolloorr((_F_a_r_b_e))
              Setzt die Farbe des Textes.

       aavvtt..sseett__tteexxtt__bbaacckkggrroouunndd__ccoolloorr((_F_a_r_b_e))
              Setzt die Hintergrundfarbe des Textes.

       aavvtt..sseett__tteexxtt__bbaacckkggrroouunndd__bbaalllloooonnccoolloorr(())
              Setzt  die Hintergrundfarbe des Textes auf die Farbe der Sprech‐
              blase.

       aavvtt..sseett__bbiittmmaapp__ccoolloorr((_F_a_r_b_e))
              Setzt die Vordergrundfarbe für  Bitmaps  (einfarbige  Grafiken).
              Der Hintergrund ist immer transparent.

       aavvtt..ggeett__ccoolloorr((_F_a_r_b_n_u_m_m_e_r))
              Hole die Farbdefinition für die angegebene Farbnummer.

              AKFAvatar  hat eine interne Palette mit englischsprachigen Farb‐
              namen, die man verwenden kann.  Mit  dieser  Funktion  kann  man
              diese  Liste durchgehen.  Sie gibt den Namen und die RGB-Defini‐
              tion als String zurück, oder es gibt  nichts  zurück,  wenn  die
              Farbnummer nicht existiert.

       aavvtt..ccoolloorrss(())
              Iterator für interne Farbnamen.

              AKFAvatar  hat eine interne Palette mit englischsprachigen Farb‐
              namen, die man verwenden kann.  Mit  dieser  Funktion  kann  man
              diese Liste mit einer allgemeinen ffoorr-Schleife durchgehen.

              require "lua-akfavatar"
              for nr, name, rgb in avt.colors() do
                avt.normal_text()
                avt.newline()
                avt.say(string.format("%3d) %5s, %-25s", nr, rgb, name))
                avt.set_text_background_color(name) -- name oder rgb
                avt.clear_eol()
                avt.wait(0.7)
              end
              avt.wait_button()

              Wenn  man  den  _r_g_b-Wert  nicht  benötigt, kann man die Variable
              weglassen.

   IInntteerraakkttiioonn
       aavvtt..wwaaiitt__bbuuttttoonn(())
              Wartet bis ein Knopf gedrückt wird.

       aavvtt..ddeecciiddee(())
              Fragt den Benutzer nach einer positiven oder negativen  Antwort.
              Gibt etweder _t_r_u_e oder _f_a_l_s_e zurück.

       aavvtt..aasskk((_[_F_r_a_g_e_]))
              Zeigt  die  _F_r_a_g_e,  falls angegeben, und wartet bis der Benutzer
              etwas eingibt.  Gibt das Eingegebene als String zurück.

              Das folgende Beispiel zeigt, wie  man  die  Eingabe  einer  Zahl
              erzwingt:

              require "lua-akfavatar"
              avt.save_position()
              repeat
                avt.restore_position()
                Zahl = tonumber(avt.ask("Gib eine Zahl ein: "))
              until Zahl
              avt.say("Die Zahl ist ", Zahl)
              avt.wait_button()

       aavvtt..ffiillee__sseelleeccttiioonn((_[_F_i_l_t_e_r_]))
              Startet einen Dateiauswahl-Dialog in der Sprechblase.  Am Anfang
              zeigt er das aktuelle Arbeitsverzeichnis an.  Wenn ein Verzeich‐
              nis ausgewählt wird, wird das zum Arbeitsverzeichnis.  Wenn eine
              Datei ausgewählt wird, wird  der  Dateiname  zurückgegeben  (die
              sich  dann  im dann aktuellen Arbeitsverzeichnis befindet), oder
              im Fehlerfall wird _n_i_l zurückgegeben.

              Der _F_i_l_t_e_r, falls angegeben, sollte  eine  Funktion  sein.   Sie
              bekommt einen Dateinamen als Parameter.  Die Datei befindet sich
              immer im aktuellen Arbeitsverzeichnis.  Wenn die Filter-Funktion
              _f_a_l_s_e oder _n_i_l oder nichts zurückgibt, dann wird die Datei nicht
              angezeigt, ansonsten wird sie angezeigt.

              BBeeiissppiieell::
               Textdatei = avt.file_selection(
                  function(n)
                    return string.find(n,"%.te?xt$")
                  end)

              Natürlich kann für _F_i_l_t_e_r auch  einfach  der  Name  einer  zuvor
              definierten Funktion angegeben werden.

       aavvtt..ccoolloorr__sseelleeccttiioonn(())
              Startet  einen Farbauswahl-Dialog in der Sprechblase.  Es werden
              zwei Strings zurückgegeben: erstens der englische Name  für  die
              Farbe und zweitens die hexadezimale RGB-Definition.  Beide Werte
              können für die Farbauswahl verwendet werden.

       aavvtt..ggeett__kkeeyy(())
              Wartet auf einen Tastendruck und gibt den Unicode-Codepoint  des
              Zeichens  zurück.   Für  einige Funktionstasten werden Werte aus
              einem Unicode-Bereich für den privaten Gebrauch zurückgegeben.

       aavvtt..kkeeyy__pprreesssseedd(())
              Prüft, ob eine Taste gedrückt wurde.  Um den  Tasten-Code  abzu‐
              holen kann man aavvtt..ggeett__kkeeyy(()) verwenden.

       aavvtt..cclleeaarr__kkeeyyss(())
              Löscht den Tastatur-Buffer

       aavvtt..ppuusshh__kkeeyy((_C_o_d_e_p_o_i_n_t))
              Simuliert einen Tastendruck

       aavvtt..nnaavviiggaattee((_b_u_t_t_o_n_s))
              Zeigt eine Navigationsleiste mit den angegebenen Knöpfen.

              Für  die  Knöpfe  kann man in einem String die folgenden Zeichen
              verwenden:

              l:     links

              r:     rechts (abspielen)

              d:     runter

              u:     hoch

              x:     abbrechen

              f:     (schnell)vorwärts

              b:     (schnell)rückwärts

              p:     Pause

              s:     Stop

              e:     Auswurf

              *:     Kreis (Aufnahme)

              +:     Plus (hinzufügen)

              -:     Minus (entfernen)

              ?:     Hilfe

              ' ':   Platzhalter (kein Knopf)

              Eine Taste mit einem dieser Zeichen zu drücken wählt diesen aus.
              Für die Richtungen kann man auch die Pfeiltasten verwenden.  Die
              <Pause>-Taste gibt "p"  zurück.   Die  <Hilfe>-Taste  oder  <F1>
              geben "?" zurück.

              Es wird das entsprechende Zeichen zurückgegeben oder eine Zahl.

              Wenn eine Audio-Ausgabe endet, während diese Funktion aktiv ist,
              wird automatisch entweder "f" (vorwärts) oder  "s"  (Stop)  aus‐
              gewählt.  Falls beides vorhanden ist, hat "f" Vorrang.

       aavvtt..mmeennuu((_M_e_n_ü_p_u_n_k_t_e))
       aavvtt..lloonngg__mmeennuu((_M_e_n_ü_p_u_n_k_t_e))
              Zeigt  ein Menü mit den angegebenen _M_e_n_ü_p_u_n_k_t_en.  Die _M_e_n_ü_p_u_n_k_t_e
              können zum Einen ein Array mit Strings sein.  Dann wird die Num‐
              mer (Position) des ausgewählten Menüpunktes zurückgegeben.

              Oder  _M_e_n_ü_p_u_n_k_t_e können ein Array mit weiteren Arrays sein.  Die
              inneren Arrays müssen dann mit einem  String  anfangen,  gefolgt
              von einem oder mehreren Egebnissen.  Die Ergebnisse können jeder
              beliebige Lua-Typ sein, einschließlich Funktionen.

              Das Menü fängt in der Zeile der  aktuellen  Cursor-Position  an.
              Dadurch kann man eine Überschrift vor das Menü setzen.

              avt.clear()
              avt.say("Bitte das Liebligsessen auswählen:\n")
              local Menuepunkt = avt.long_menu {
                "Chicken",
                "Chips",
                "Pizza",
                "Spinach"}

       aavvtt..cchhooiiccee((_A_n_f_a_n_s_z_e_i_l_e_, _E_i_n_t_r_ä_g_e _[_, _T_a_s_t_e_] _[_, _z_u_r_ü_c_k_] _[_, _v_o_r_w_ä_r_t_s_]))
              Diese  Funktion  kann  für  Menüs verwendet werden.  Es ist eine
              grundlegendere Funktion, als aavvtt..mmeennuu(()).  Es gibt die Nummer den
              ausgewählten Menüpunktes zurück.

              _A_n_f_a_n_g_s_z_e_i_l_e:
                     die Zeile, in der die Auswahl beginnt

              _E_i_n_t_r_ä_g_e:
                     Anzahl der Einträge (Zeilen)

              _T_a_s_t_e: Anfangstaste,  wie  "1"  oder  "a", 0 für keine Tastenun‐
                     terstützung

              _z_u_r_ü_c_k:
                     auf _t_r_u_e zu setzen, wenn der erste Eintrag  eine  zurück-
                     Funktion hat

              _v_o_r_w_ä_r_t_s:
                     auf  _t_r_u_e zu setzen, wenn der letzte Eintrag eine weiter-
                     Funktion hat

   AAuuddiioo--AAuussggaabbee
       aavvtt..ssttaarrtt__aauuddiioo(())
              Startet das Audio-Untersystem.

              Bei Erfolg gibt es _t_r_u_e zurück, im Fehlerfall gibt  es  _n_i_l  und
              eine Fehlermeldung zurück.

       aavvtt..llooaadd__aauuddiioo__ffiillee((_[_D_a_t_e_i_n_a_m_e _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
       aavvtt..llooaadd__bbaassee__aauuddiioo__ffiillee((_[_D_a_t_e_i_n_a_m_e _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
              Liest   Audio-Daten   von   einer   Datei  ein.   Man  kann  mit
              aavvtt..sseeaarrcchh(()) nach der Datei suchen lassen.

              Lua-Module können Unterstützung  für  weitere  Audio-Formate  zu
              aavvtt..llooaadd__aauuddiioo__ffiillee(())  hinzufügen.   (Das  tut  zum Beispiel das
              Modul aakkffaavvaattaarr--vvoorrbbiiss).

              Wenn kein _D_a_t_e_i_n_a_m_e angegeben ist, oder der  _D_a_t_e_i_n_a_m_e  ist  _n_i_l
              oder  ein  leerer  String,  wird  ein  Audio-Element  mit Stille
              zurückgegeben, das heißt, man kann die Methoden  aufrufen,  aber
              es wird kein Klang ausgegeben.

              _A_b_s_p_i_e_l_m_o_d_u_s kann entweder "load", "play" oder "loop" sein.

              Bei  Fehlern  wird  _n_i_l  und  eine  Fehlermelung  zurückgegeben.
              (Anmerkung: in  Version  0.19.0  wurde  dann  auch  eine  Stille
              zurückgegeben.)

       aavvtt..llooaadd__aauuddiioo__ssttrreeaamm((_D_a_t_e_i _[_,_G_r_ö_ß_e _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
       aavvtt..llooaadd__bbaassee__aauuddiioo__ssttrreeaamm((_D_a_t_e_i _[_,_G_r_ö_ß_e _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
              Liest Audio-Daten von einer geöffneten Datei.

              Lua-Module  können  Unterstützung  für  weitere Audio-Formate zu
              aavvtt..llooaadd__aauuddiioo__ssttrreeaamm(()) hinzufügen.  (Das tut zum  Beispiel  das
              Modul aakkffaavvaattaarr--vvoorrbbiiss).

              Wenn keine Größe angegeben ist, wird davon ausgegangen, dass die
              Audio-Daten bis zum Ende der Datei gehen.

              _A_b_s_p_i_e_l_m_o_d_u_s kann entweder "load", "play" oder "loop" sein.

              Bei Fehlern wird _n_i_l und eine Fehlermelung zurückgegeben.

       aavvtt..llooaadd__aauuddiioo((_[_A_u_d_i_o_d_a_t_e_n _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
       aavvtt..llooaadd__bbaassee__aauuddiioo((_[_A_u_d_i_o_d_a_t_e_n _[_,_A_b_s_p_i_e_l_m_o_d_u_s_]_]))
              Liest Audiodaten aus einem String.   Ansonsten  das  selbe,  wie
              aavvtt..llooaadd__aauuddiioo__ffiillee(()).

              Lua-Module  können  Unterstützung  für  weitere Audio-Formate zu
              aavvtt..llooaadd__aauuddiioo(()) hinzufügen.  (Das tut zum  Beispiel  das  Modul
              aakkffaavvaattaarr--vvoorrbbiiss).

              Wenn  keine  _A_u_d_i_o_d_a_t_e_n  angegeben sind, oder _A_u_d_i_o_d_a_t_e_n ist _n_i_l
              oder ein  leerer  String,  wird  ein  Audio-Element  mit  Stille
              zurückgegeben,  das  heißt, man kann die Methoden aufrufen, aber
              es wird kein Klang ausgegeben.

              _A_b_s_p_i_e_l_m_o_d_u_s kann entweder "load", "play" oder "loop" sein.

              Bei  Fehlern  wird  _n_i_l  und  eine  Fehlermelung  zurückgegeben.
              (Anmerkung:  in  Version  0.19.0  wurde  dann  auch  eine Stille
              zurückgegeben.)

       aavvtt..ssiilleenntt(())
              Gibt ein stilles Audio-Element zurück, das heißt, man  kann  die
              Methoden aufrufen, aber es wird kein Klang ausgegeben.

              BBeeiissppiieell::
              audio = avt.load_audio_file(Dateiname) or avt.silent()

              In  diesem  Beispiel  bekommt  man einen stillen Klang, wenn die
              Datei nicht gelesen werden konnte.

       aavvtt..aalleerrtt(())
              Gibt  ein  Pseudo-Audio-Element   zurück,   welches   aavvtt..bbeellll(())
              aufruft, wenn man es abspielt.

       aavvtt..ffrreeqquueennccyy((_F_r_e_q_u_e_n_z _[_, _L_a_u_t_s_t_ä_r_k_e_]))
              Erzeugt  ein Audio-Element mit einem kurzen Ton in der angegebe‐
              nen _F_r_e_q_u_e_n_z (in Hertz (Hz), auf eine Ganzzahl gerundet) mit der
              angegebenen  _L_a_u_t_s_t_ä_r_k_e  (0-100, Vorgabe 75).  Dieses Audio-Ele‐
              ment kann problemlos als Schleife wiedergegeben werden.

              BBeeiissppiieell::
              avt.frequency(440):loop()

       aavvtt..aauuddiioo__ppllaayyiinngg((_[_A_u_d_i_o_d_a_t_e_n_]))
              Überprüft, ob Audiodaten gerade abgespielt werden.  Wenn  _A_u_d_i_o_‐
              _d_a_t_e_n  angegeben  ist und nicht _n_i_l ist, dann wird überprüft, ob
              die angegebenen Audiodaten  abgespielt  werden.   Das  kann  man
              übrigens auch mit _a_u_d_i_o::ppllaayyiinngg(()) überprüfen.

       aavvtt..wwaaiitt__aauuddiioo__eenndd(())
              Wartet, bis die Audio-Ausgabe beendet ist.

              Dadurch  wird  auch  eine Audio-Schleife beendet, aber es spielt
              halt noch bis zum Ende des aktuellen Klanges.

       aavvtt..ssttoopp__aauuddiioo(())
              Stoppt die Audio-Ausgabe sofort.

       aavvtt..ppaauussee__aauuddiioo((_t_r_u_e||_f_a_l_s_e))
              Die Audio-Ausgabe wird  pausiert  (_t_r_u_e)  oder  weiter  gespielt
              (_f_a_l_s_e)

       _a_u_d_i_o::ppllaayy(())
       _a_u_d_i_o(())
              Spielt die Audiodaten _a_u_d_i_o ab.

              Es  kann nur ein Klang gleichzeitig abgespielt werden.  Wenn man
              einen anderen Klang abspielt, wird der vorherige  dadurch  abge‐
              brochen.   Man  kann  aavvtt..wwaaiitt__aauuddiioo__eenndd(())  verwenden, um Klänge
              nacheinander abzuspielen.

              Man kann den Klang auch abspielen, indem man die  Audio-Variable
              wie eine Funktion aufruft.

              abspielen = function (Dateiname)
                local Klang = avt.load_audio_file(avt.search(Dateiname))
                if Klang then Klang:play() end
              end

       _a_u_d_i_o::lloooopp(())
              Spielt die Audiodaten _a_u_d_i_o in einer Schleife ab.

              Das ist zum Beispiel für eine kurze Musik-Sequenz nützlich.

              Man   kann  die  Audio-Schleife  mit  aavvtt..wwaaiitt__aauuddiioo__eenndd(())  oder
              aavvtt..ssttoopp__aauuddiioo(()) beenden.

       _a_u_d_i_o::ppllaayyiinngg(())
              Überprüft, ob diese _a_u_d_i_o-Daten gerade abgespielt  werden.   Die
              Audiodaten   _a_u_d_i_o   müssen   mit   aavvtt..llooaadd__aauuddiioo__ffiillee(())   oder
              aavvtt..llooaadd__aauuddiioo__ssttrriinngg(()) geladen worden sein.

              Diese Funktion ist identisch mit aavvtt..aauuddiioo__ppllaayyiinngg((aauuddiioo)).

       _a_u_d_i_o::ffrreeee(())
              Gibt die _a_u_d_i_o-Daten frei.  Falls diese _a_u_d_i_o-Daten gerade abge‐
              spielt werden, wird die Audio-Ausgabe abgebrochen.

              Audiodaten werden auch vom Garbage Collector freigegeben.

       aavvtt..sseett__aauuddiioo__eenndd__kkeeyy ((_T_a_s_t_e))
              Definiere eine Taste, die automatisch gedrückt werden soll, wenn
              die Audio-Ausgabe endet.  Die _T_a_s_t_e sollte als Zahl für den Uni‐
              code-Codepoint  angegeben werden.  Durch den Wert _0 kann man das
              wieder abschalten.

              Die Funktion gibt den voher gesetzten Wert zurück.

       aavvtt..qquuiitt__aauuddiioo(())
              Das Audio-Untersystem beenden.

              Das ist bei normalen Programmen  nicht  nötig.   Diese  Funktion
              sollte nur verwendet werden, wenn man weiß, was man tut.

   DDaatteeiissyysstteemm
       aavvtt..ddiirrsseepp
              Diese Variable enthält das Verzeichnis-Trennzeichen des Systems;
              entweder "/" oder "\".

       aavvtt..ddaattaappaatthh
              Diese Variable enthält den  Standardsuchpfad  für  die  Funktion
              aavvtt..sseeaarrcchh(()) (siehe unten).  Verzeichnisse werden durch Semikola
              getrennt.  Es gibt keine Muster, wie in den Pfaden für  Lua-Mod‐
              ule, sondern es werden nur Verzeichnisse angegeben.  Diese Vari‐
              able wird entweder durch die Umgebungsvariable _A_V_T_D_A_T_A_P_A_T_H  ini‐
              tialisiert,  oder sie bekommt eine systemspezifische Vorgabeein‐
              stellung.

       aavvtt..sseeaarrcchh((_D_a_t_e_i_n_a_m_e _[_,_P_f_a_d_]))
              Sucht eine Datei mit dem angegebenen _D_a_t_e_i_n_a_m_en  im  angegebenen
              _P_f_a_d.  Wenn kein _P_f_a_d angegeben ist, wird die Variable _a_v_t_._d_a_t_a_‐
              _p_a_t_h verwendet.

              Wenn die Datei gefunden wurde, wird der  vollständige  Pfad  der
              Datei  zurückgegeben.  Wenn die Datei nicht gefunden wurde, wird
              _n_i_l und eine Fehlermeldung zurückgegeben.

       aavvtt..ggeett__ddiirreeccttoorryy(())
       aavvtt..ggeettccwwdd(())
              Gibt das aktuelle Arbeitsverzeichnis zurück.  Im Fehlerfall wird
              _n_i_l und eine Fehlermeldung zurückgegeben.

       aavvtt..sseett__ddiirreeccttoorryy((_d_i_r_e_c_t_o_r_y))
       aavvtt..cchhddiirr((_V_e_r_z_e_i_c_h_n_i_s))
              Setzt  das Arbeitsverzeichnis auf _V_e_r_z_e_i_c_h_n_i_s.  Wenn _V_e_r_z_e_i_c_h_n_i_s
              _n_i_l ist, ein Leerstring oder nicht angegeben  ist,  wird  nichts
              ausgeführt.

              Gibt  bei  Erfolg _t_r_u_e zurück oder bei einem Fehler _n_i_l und eine
              Fehlermeldung.

              BBeeiissppiieell::
              avt.set_directory(os.getenv("HOME") or os.getenv("USERPROFILE"))

       aavvtt..ddiirreeccttoorryy__eennttrriieess((_[_V_e_r_z_e_i_c_h_n_i_s_]))
              Hole eine Liste von Verzeichniseinträgen vom angegebenen  _V_e_r_z_e_‐
              _i_c_h_n_i_s   oder   dem  aktuellen  Arbeitsverzeichnis,  wenn  keins
              angegeben ist.

              Bei Erfolg gibt es ein Array mit den Verzeichniseinträgen zurück
              und  die  Anzahl  der Einträge.  Im Fehlerfall wird _n_i_l und eine
              Fehlermeldung zurückgegeben.

              Die Liste enthält sowohl normale Dateinamen, einschließlich ver‐
              stecken   Dateien,   Unterverzeichnisse  und  andere  Arten  von
              Einträgen.  Die Einträge "." oder ".." sind nicht mit drin.

              Achtung: Die Namen sind in einer  systemspezifischen  Kodierung.
              Um die Namen anzeigen zu können, muss man entweder die Kodierung
              der Anzeige mit aavvtt..eennccooddiinngg((""SSYYSSTTEEMM"")) ändern,  oder  die  Namen
              wie folgt konvertieren: aavvtt..ssaayy((aavvtt..rreeccooddee((nnaammee,, ""SSYYSSTTEEMM"")))).

       aavvtt..eennttrryy__ttyyppee((_E_i_n_t_r_a_g))
              Ermittle die Art eines Verzeichniseintrags und seine Größe.

              Bei  Erfolg  gibt  es die Art des Verzeichniseintrags als String
              zurück und die Größe als Zahl.  Die  Art  ist  entweder  "file",
              "directory",   "character   device",   "block  device",  "fifo",
              "socket" oder "unknown".

              Im Fehlerfall wird _n_i_l und eine Fehlermeldung zurückgegeben.

              Symbolische Links werden ausgewertet.  Das bedeutet, man bekommt
              die  Art  des resultierenden Eintrags.  Kaputte Links werden wie
              nicht existierende Einträge behandelt.

   VVeerrsscchhiieeddeenneess
       aavvtt..llaanngguuaaggee
              Diese Variable  enthält  einen  Sprachcode  für  Meldungen.   Es
              sollte  sich um eine Kennung mit zwei Buchstaben gemäß ISO 639-1
              handeln.  Wenn die Sprache nicht ermittelt  werden  konnte,  ist
              die Variable nicht gesetzt.

       aavvtt..ttrraannssllaattee((_T_e_x_t))
              Übersetzt den _T_e_x_t, falls möglich.

              Wie  man Übersetzungen angeben kann, steht im Abschnitt ÜÜbbeerrsseett‐‐
              zzuunnggeenn.

       aavvtt..rreeccooddee((_S_t_r_i_n_g_, _Q_u_e_l_l_k_o_d_i_e_r_u_n_g _[_,_Z_i_e_l_k_o_d_i_e_r_u_n_g_]))
              Konvertiert  den  angegebenen  _S_t_r_i_n_g,  der  in   _Q_u_e_l_l_k_o_d_i_e_r_u_n_g
              kodiert  ist,  in einen String der in _Z_i_e_l_k_o_d_i_e_r_u_n_g kodiert ist.
              Wenn nur eine Kodierung angegeben  ist,  kovertiert  es  in  die
              aktuell   gesetzte  Kodierung.   Falls  man  von  der  aktuellen
              Kodierung in etwas anderes kovertieren will, kann  man  _n_i_l  für
              die _Q_u_e_l_l_k_o_d_i_e_r_u_n_g angeben.

              Um   in   die   oder   aus  der  Standardkodierung  des  Systems
              umzukodieren (zum  Beispiel  für  Dateinamen),  kann  man  einen
              leeren String (_"_") oder _"_S_Y_S_T_E_M_" angeben.

              Gibt  den  kodierten  String  zurück,  oder  _n_i_l,  bei  schweren
              Fehlern.

              AAcchhttuunngg:: Nach UTF-8 zu konvertieren  ist  immer  möglich.   Nach
              anderen  Kodierungen  zu konvertieren, kann jedoch fehlschlagen.
              Zeichen, die nicht konvertiert werden können, werden  durch  das
              Steuerzeichen  _S_U_B (_"_\_x_1_A_") ersetzt.  Um sicher zu stellen, dass
              die Konvertierung verlustfrei ablief, kann man überprüfen,  dass
              dieses Zeichen im Ausgabestring nicht vorkommt.

       aavvtt..rriigghhtt__ttoo__lleefftt((_t_r_u_e||_f_a_l_s_e))
              Aktiviert, oder deaktiviert den rechts-nach-links-Schreibmodus.

              AAcchhttuunngg::  Dies  ist  noch  experimentell  und  funktioniert  nur
              eingeschränkt.

       aavvtt..sseett__fflliipp__ppaaggee__ddeellaayy((_[_d_e_l_a_y_]))
              Setzt eine Verzögerung  für  aavvtt..fflliipp__ppaaggee(())  oder  "\f".   Ohne
              Angabe  eines  Wertes  wird  auf die Vorgabe zurückgesetzt.  Der
              Wert 0 schaltet die Verzögerung ganz aus.

       aavvtt..aaccttiivvaattee__ccuurrssoorr((_t_r_u_e||_f_a_l_s_e))
              Legt fest, ob der Cursor angezeigt wird, oder nicht.

       aavvtt..cclleeaarr__ssccrreeeenn(())
              Löscht den gesamten Bildschirm, bzw. das Fenster (nicht nur  die
              Sprechblase!).

       aavvtt..cclleeaarr__ddoowwnn(())
              Löscht  von  der  Cursor-Postition nach unten im Anzeigebereich.
              Wenn noch keine Sprechblase angezeigt wird, wird sie gezeichnet.

       aavvtt..cclleeaarr__eeooll(())
              Löscht das Ende der Zeile (abhängig von der Text-Richtung).

       aavvtt..cclleeaarr__bbooll(())
              Löscht den Anfang der Zeile (abhängig von der Text-Richtung).

       aavvtt..cclleeaarr__lliinnee(())
              Löscht die Zeile.

       aavvtt..cclleeaarr__uupp(())
              Löscht von der Cursor-Postition  nach  oben  im  Anzeigebereich.
              Wenn noch keine Sprechblase angezeigt wird, wird sie gezeichnet.

       aavvtt..rreesseerrvvee__ssiinnggllee__kkeeyyss((_t_r_u_e||_f_a_l_s_e))
              Reserviert Einzeltasten, wie <ESC> oder <F11>.

       aavvtt..sswwiittcchh__mmooddee((_m_o_d_e))
              Ändert  den  Fenster-Modus.  Man kann es entwerder auf _"_w_i_n_d_o_w_",
              oder _"_f_u_l_l_s_c_r_e_e_n_" setzen.

              (Die Modi _"_a_u_t_o_" und  _"_f_u_l_l_s_c_r_e_e_n _n_o _s_w_i_t_c_h_" funktionieren hier‐
              mit nicht.)

       aavvtt..ggeett__mmooddee(())
              Gibt den Fenster-Modus zurück (siehe aavvtt..sswwiittcchh__mmooddee ((mmooddee))).

       aavvtt..ttooggggllee__ffuullllssccrreeeenn(())
              Schaltet den Vollbild-Modus ein oder aus.

       aavvtt..uuppddaattee(())
              Aktualisiert  alles  und  reagiert  auf Ereignisse.  Dies sollte
              innehalb von Schleifen ausgeführt werden, während  das  Programm
              mit anderem beschäftigt ist.

       aavvtt..ccrreeddiittss((_t_e_x_t_, _c_e_n_t_e_r_e_d))
              Zeigt einen Abspann.

              Wenn der zweite Parameter _t_r_u_e ist, wird jede Zeile zentriert.

       aavvtt..vviieewwppoorrtt((_x_, _y_, _w_i_d_t_h_, _h_e_i_g_h_t))
              Setzt  einen  Anzeigebereich  (einen  Unterbereich des Textbere‐
              iches).  Die obere linke Ecke hat die Koordinaten 1, 1.

       aavvtt..sseett__ssccrroollll__mmooddee((_M_o_d_u_s))
              Setzt den Rollmodus, dh. wie er reagiert, wenn  man  hinter  der
              letzten  Zeile  weiter  schreibt.  Der _M_o_d_u_s ist entweder -1 für
              "nichts  tun"  oder  0  für  "Seite  umblättern"  oder   1   für
              "hochrollen".

       aavvtt..ggeett__ssccrroollll__mmooddee(())
              Gibt den Rollmodus zurück (siehe aavvtt..sseett__ssccrroollll__mmooddee(())).

       aavvtt..nneewwlliinnee__mmooddee((_t_r_u_e||_f_a_l_s_e))
              Wenn  der  Neue-Zeile-Modus  aktiviert ist (Vorgabe), dann setzt
              ein Zeilenvorschub-Zeichen den Cursor an den Anfang einer  neuen
              Zeile.   Wenn  er aus ist, geht der Cursor in die nächste Zeile,
              bleibt aber in der selben horizontalen Position.

       aavvtt..sseett__aauuttoo__mmaarrggiinn((_t_r_u_e||_f_a_l_s_e))
              Setzt den Modus für automatischen  Zeilenumbruch,  dh.  ob  eine
              neue  Zeile  angefangen werden soll, wenn der Text nicht in eine
              Zeile passt.

       aavvtt..ggeett__aauuttoo__mmaarrggiinn(())
              Gibt den Modus für automatischen Zeilenumbruch zurück.

       aavvtt..sseett__oorriiggiinn__mmooddee((_t_r_u_e||_f_a_l_s_e))
              Setzt den Ursprungs-Modus.  Wenn der Ursprungs-Modus eingeschal‐
              tet  ist,  sind  die  Koordinaten  1,  1 immer oben links in der
              Sprechblase, auch dann, wenn der Anzeigebereich (viewport) nicht
              dort  beginnt.  Wenn der Ursprungs-Modus ausgeschaltet ist, sind
              die Koordinaten 1, 1 oben links im Anzeigebereich (viewport).

       aavvtt..ggeett__oorriiggiinn__mmooddee(())
              Gibt den Ursprings-Modus zurück (siehe aavvtt..sseett__oorriiggiinn__mmooddee).

       aavvtt..sseett__mmoouussee__vviissiibbllee((_t_r_u_e||_f_a_l_s_e))
              Legt fest, ob der Mauszeiger sichtbar sein soll, oder nicht.

              AAnnmmeerrkkuunngg:: Wenn die Anwendung in einem Fenster läuft,  gilt  das
              nur, wenn sich der Mauszeiger innerhalb des Fensters befindet.

       aavvtt..lloocckk__uuppddaatteess((_t_r_u_e||_f_a_l_s_e))
              Blockiert  Aktualisierungen innerhalb der Sprechblase.  Das kann
              man verwenden um die Geschwindigkeit zu erhöhen.

       aavvtt..vveerrssiioonn(())
              Gibt die Version von AKFAvatar als String zurück.

       aavvtt..ccooppyyrriigghhtt(())
              Gibt die Copyright-Meldung für AKFAvatar als String zurück.

       aavvtt..lliicceennssee(())
              Gibt die Lizenz-Meldung für AKFAvatar als String zurück.

       aavvtt..qquuiitt(())
              Beendet das AKFAvatar Untersystem (schließt das  Fenster).   Das
              Audio-Untersystem wird ebenfalls beendet.

              Diese  Funktion wird nicht in normalen Programmen benötigt.  Man
              sollte sie nur verwenden, wenn das Programm ohne sichbares  Fen‐
              ster weiter laufen soll.

       aavvtt..llaauunncchh((_P_r_o_g_r_a_m_m _[_,_A_r_g_u_m_e_n_t_e _._._._]))
              Beendet  AKFAvatar und führt das angegebene _P_r_o_g_r_a_m_m aus.  Diese
              Funktion kehrt niemals zurück.   Entweder  das  Programm  läuft,
              oder es wird ein fataler Fehler angezeigt.

              Wenn  man  Fehler mit ppccaallll abfangen will, muss man danach AKFA‐
              vatar neu initialisieren...

ÜÜbbeerrsseettzzuunnggeenn
       Um Übersetzungen für Lua-AKFAvatar Skripte zu schreiben, muss man erst‐
       mal die Variable aavvtt..ttrraannssllaattiioonnss definieren.  Es handelt sich dabei um
       eine verschachtelte Tabelle.  Nun, die ist schwer zu beschreiben,  aber
       das Beispiel-Skript weiter unten sollte es verständlich machen.

       Die  zu  verwendende Sprache wird durch die Variable aavvtt..llaanngguuaaggee fest‐
       gelegt.  Diese Variable sollte von Lua-AKFAvatar  automatisch  initial‐
       isiert  worden sein, sie kann aber auch im Skript geändert werden.  Sie
       enthält eine Sprach-Kennung mit zwei Buchstaben gemäß ISO 639-1.

       Die Funktion aavvtt..ttrraannssllaattee((_T_e_x_t)) gibt dann den übersetzten Text zurück.
       Falls  keine Übersetzung zur Verfügung steht, wird der Text unverändert
       zurück gegeben.

       Es ist ratsam, einen lokalen Alias namens LL für  aavvtt..ttrraannssllaattee  anzule‐
       gen:
         local L = avt.translate
       Dann kann man einfach eine String-Konstante damit einleiten.

       BBeeiissppiieell:
       local avt = require "lua-akfavatar"

       avt.encoding("UTF-8")

       avt.translations = {

         ["Hello world!"] = {
           es="¡Hola mundo!",
           fr="Bonjour le monde!",
           de="Hallo Welt!",
           sv="Hej Världen!",
           },

         ["That's live!"] = {
           de="So ist das Leben!",
           fr="C'est la vie!" },
       }

       local L = avt.translate

       -- avt.language = "de"

       avt.start()
       avt.avatar_image("default")
       avt.tell(L"Hello world!", "\n", L"That's live!");
       avt.wait_button ()

       TTiippppss:

       – Obwohl   es  nicht  notwendig  ist,  sollte  man  Englisch  als  Aus‐
         gangssprache verwenden.

       – Wenn man Text mit Variablen dazwischen hat, ist es kein guter Ansatz,
         den Text in Teile aufzuteilen.  Es ist besser einen Format-String für
         ssttrriinngg..ffoorrmmaatt(()) zu definieren.

       – Der übersetzbare  String  muss  exakt  übereinstimmen.   Bitte  daran
         denken, wenn man die Strings im Programm abändert, dass man dann auch
         die Übersetzungstabelle anpassen muss!

       – Der String kann auch ein  Dateiname  für  eine  Textdatei  oder  eine
         Sprachaufnahme sein.

       Übrigens, diese Implementierung wurde von GNU gettext inspiriert.

SSIIEEHHEE AAUUCCHH
       lluuaa--aakkffaavvaattaarr(1)  lluuaa(1)  aakkffaavvaattaarr--ggrraapphhiicc(3)  aakkffaavvaattaarr--tteerrmm(3) aakkffaa‐‐
       vvaattaarr..uuttff88(3)
       hhttttpp::////lluuaa..ccooddeerrss--oonnlliinnee..nneett//
       hhttttpp::////wwwwww..lluuaa..oorrgg//mmaannuuaall//55..22//
       hhttttpp::////aakkffaavvaattaarr..nnoonnggnnuu..oorrgg//mmaannuuaall//



AKFAvatar                         2013-10-02         Lua-AKFAvatar Referenz(3)
