Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

Allegro-Freebasic-Tutorials

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Bibliotheken
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Eastler_dart



Anmeldungsdatum: 24.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 04.01.2006, 20:09    Titel: Allegro-Freebasic-Tutorials Antworten mit Zitat


Allegro starten tutorial - Version 27.Feb 2006 - Eastler_Dart
Achten Sie Stets auf die Version, falls ich neue Erkenntnisse erlange, werde ich hier per EDIT das Tutorial ändern und entsprechend das Versionsdatum anpassen.

Link für alleg40.dll auf meine Seite eingefügt, Angaben zu Linux erweitert


Vorwort

Hallo Leute

Im Moment plage ich mich mit Allegro rum, da ich ein Prog erstellen will, welches Plattformübergreifend laufen kann, also unter Linux, Win32 und reinem DOS.

Eigentlich läuft die Sache jetzt ja super, aber der Einstieg, also bis mal Allegro unter Freebasic ordentlich eingebunden und gestartet ist, war doch sehr schwer da ungewohnt.

Die Tatsache, daß ordentliche Tutorials oder Beispiele kaum zu finden sind, macht das Ganze auch nicht leichter. Das meißte, was ich an Hilfestellungen gefunden habe, bezieht sich immer auf Programmerstellungen unter C und nicht unter Basic. Gleichfalls sind diese Tutorials nur in englisch oder französisch zu finden, in deutscher Sprache ist sowas absolut Mangelware traurig

Somit hab ich hier einfach mal ein kleines Tutorial zusammengestellt, sodaß ein Einstieg in das ganze erst mal möglich wird.

Was haben wir vor?
Als Lehrstück erstellen wir ein kleines FreeBasic-Programm, in dem Allegro eingebunden und Initialisiert wird. Zusätzlich starten wir die Grafikfunktionen und den Tastaturtreiber von Allegro

Grundlagen schaffen:
Als erstes ist zu prüfen, ob Allegro in Ihrem FreeBasic-System bereits vorhanden ist. FreeBasic hat es sich zwar auf die Fahne geschrieben, daß Allegro bereits integriert wäre, aber zu meiner Überraschung mußte ich feststellen, daß dies unter der FB-Version 0.15 nicht mehr automatisch der Fall ist. Nachfolgende Dateien müssen vorhanden sein. Falls dies bei Ihnen nicht so ist, steht zu jeder Rubrik ein Tip, wie sie dies nachtragen können.

1)in allen FreeBasic-Versionen (Dos/Win/Linux) in Ihrem FreeBasic-Ordner unter inc die Datei allegro.bi .
In den DOS-Versionen von FreeBasic wird dieses auch bereits automatisch so eingerichtet. Aber bei FreeBasic-Windows muß beim Installieren von Freebasic die Rubrik Bibliotheken aufgeklappt und Allegro per Haken setzen aktiviert werden. Bezüglich Linux kann ich derzeit nicht sagen, wie diese Datei ins FreeBasic-System zu stellen ist, falls allegro.bi nicht automatisch mit erstellt wird.

2a)in der DOS-Version von FreeBasic in Ihrem FreeBasic-Ordner unter lib/dos die Datei liballeg.a (wird automatisch erstellt)

2b)in der Windows-Version von FreeBasic in Ihrem FreeBasic-Ordner unter lib/win32 die Datei liballeg.dll.a (sobald Sie im FB-Installer Allegro aktiviert haben (siehe Pkt 1) wird auch diese liballeg.dll.a erstellt.

2c)in der Linux-Version von FreeBasic konnte ich noch nicht prüfen, ob unter lib/ eine liballeg-Datei notwendig ist und ob diese ggf. automatisch erstellt wird.

3)in der Windows-Version von FreeBasic in dem Verzeichnis, in dem Sie ihre compilierte MeinProg.EXE starten, die Datei alleg40.dll . Es würde auch funktionieren, diese Dll ins Windows-Verzeichnis zu kopieren, jedoch müßten Sie dann für ein Umstellen auf einen anderen Rechner/weitergeben Ihres Programmes diese alleg40.dll erst mal suchen, um diese dann ebenfalls weiterzugeben.
Die Alleg40.dll wird von FreeBasic nicht mitgeliefert. Jedoch ist diese Datei einfach per Internet-Download zu bekommen:
a) im Download-Sektor der Qbasic-FreeBasic-Seite: http://fb.exp-soft.de/FBdownloads.php?zeig=downloads&in1=&in2=Bibliotheken%20(Libraries). Dabei handelt es sich um ein Zip-Archiv mit ca 4.5MB, in welchem die *.DLL-Dateien für viele Bibliotheken enthalten sind.
b) auf meiner (Eastler) Homepage die reine alleg40.dll (ungepackt traurig) runterziehen mit 888.513 bytes
http://www.eastler.de/FreeBasic ....Ihr findet die schon lächeln
c) Für die reine alleg40.dll als Zip-Archiv alldll40.zip mit 318 KB findet ihr mit Google "alleg40.dll download" ettliche adressen. Achte darauf, diejenige DLL zu ziehen, die zu deinem Betriebssystem (Win/Linux?) gehört.

4)nur unter DOS wird noch eine Datei CWSDPMI.EXE benötigt. Dies hat zwar nur mit FreeBasic-Für-DOS direkt zu tun, ist aber auch eine Stolperfalle fürs Beginnen mit Allegro, da diese Datei unter FB0.15DOS auch nicht mit beigegeben ist. Diese CWSDPMI.EXE muß in dem Verzeichnis liegen, aus dem Sie Ihr MeinProg.EXE starten werden.
In der FB0.14DOS-Installation findet man diese Datei. Oder unter http://clio.rice.edu/cwsdpmi/ auch erhältlich.

5)in Linux hab ich noch nicht weiter geforscht, genaueres trag ich dann noch nach. Aber laut allegro.bi steht für Linux fest, daß der Pfad für die Library mit $libpath: "/usr/local/lib" und mit $libpath: "/usr/X11R6/lib" dort angegeben wird. So wie das in FreeBasic immer gepaßt hat, wird dies durch das Installationspaket der Allegro-Freebasic-Library automatisch ins richtige Verzeichnis passieren lächeln . Als Library-Bezeichnung wird in allegro.bi der Name: inclib: "alleg-4.0.3" angegeben, dieses Installationspaket sollten Sie also suchen und installieren, bzw. den Source zu ziehen, compilieren und das dann per make installieren.

Allegro in FreeBasic einbinden
So, nachdem nun alle Voraussetzungen geschaffen sind, können wir loslegen. In unserem Programm müssen wir zuallererst FreeBasic sagen, daß es mit Allegro zusammenarbeiten soll, dies geschieht mit einer einzigen Programmzeile, die ganz am Anfang unseres Programmes stehen sollte:
Code:
'$include: 'inc\allegro.bi'

Dabei ist lediglich zu beachten, daß die Pfadangabe zum "inc"-Verzeichnis richtig gesetzt wird. Ebenfalls zu beachten ist, unter welchem Betriebssystem Sie programmieren. Unter Linux sollte in der Pfadangabe statt '\' ein '/' verwendet werden.
Die zwei Punkte besagen, ein Verzeichnis nach oben wechseln. Sollten Sie also (wie ich das immer einteile) im FreeBasic-Verzeichnis einen Ordner "Projekt" und darin einen Ordner "Allegro" angelegt haben, um darin unser Programm zu speichern, dann würde die include-Angabe so heißen müssen: ..\..\inc\allegro.bi. Oder aber, sie setzen Ihr FreeBasic-Hauptverzeichnis in den Suchpfad von Win oder DOS, dann genügt ein inc\allegro.bi. Jedoch ist es hierbei nicht möglich, mit zweierlei FreeBasic-Versionen gleichzeitig zu arbeiten. (also FB-Dos und FB-Win auf einem Rechner).

Allegro initialisieren
Damit unser Programm im Hauptteil übersichtlich bleibt, führen wir den Allegro-Start in einer FUNCTION aus. Durch Verwendung einer FUNCTION statt SUB können wir einen Rückgabewert erstellen, der über eventuelle Fehler aufklärt.
Der FUNCTION geben wir auch gleich noch die gewünschte Grafik-Auflösung
640pixel X 480pixel X 8bit(256Col) mit:
Code:
'Allegro.Bas    Grundgeruest um Allegro in Freebasic einzubinden
'---------------------------------------------------------------
'Initialisierungsbereich
'=======================
'$include: 'inc\allegro.bi'
DECLARE FUNCTION Allegro_starten%(ScrBreite%, ScrHoehe%, ScrTiefe%)
'
'Hauptteil
'=========
Erfolg% = Allegro_starten%(640, 480, 8)
'
'Unterprogramme
'==============
FUNCTION Allegro_starten%(ScrBreite%, ScrHoehe%, ScrTiefe%)
   ReturnWert%=0
   'Hier dann die Startbefehle rein
AllegroEnde:
   Allegro_starten%=ReturnWert%
END FUNCTION


Das Initialisieren bedeutet nur, daß Allegro seine Grund-Daten etc auf gültige Werte stellt. Grafikfunktionen, Tastatur, Maus oder Sound sind danach noch separat zu starten.
Hierbei verwenden wir die Automatik-Routine allegro_init(). Dabei handelt es sich um eine Funktion, die auch einen Rückgabewert erstellt, sodaß geprüft werden kann, ob die Initialisierung erfolgreich verlaufen ist. Gibt die Funktion den wert 0(NULL) zurück, ist alles ok, ansonsten ist ein Fehler aufgetreten.
Die Schreibweise für solche Funktionen ist identisch mit denen für FreeBasic-Funktionen, also: Rückgabewertvariable = Funktion() oder IF Funktion()<>0 THEN Call Fehlerroutine. In unserem Fall bedeutet dies also:
Code:
  'Allegro-Init aufrufen und bei Fehler reagieren:
  IF (allegro_init() <> 0) THEN
    ReturnWert%=-1
    GOTO AllegroEnde
  END IF

Nachdem nun Allegro initialisiert ist, stehen die ersten Informationen aus der Allegrobibliothek bereit: In der Variablen allegro_id steht die Version von Allegro, in os_type steht eine Schlüsselnummer, nach der festgestellt werden kann, unter welchem Betriebssystem Ihr Programm grad läuft. In os_version und os_revision die entsprechenden Infos zur Betriebssystemversion. In os_multitasking (True/False) ist festgehalten, ob multitasking läuft.
Die Variablen-Angaben zur CPU(Prozessor), zum Desktop und die Grafik-Modi-Liste laß ich hier erst mal weg, da diese nur ab und zu von Allegro bestückt werden, und somit uninteressant sind.

Diese Variablen stehen jetzt schon zur Verfügung, aber wir zeigen diese erst an, wenn ein Grafikmodus eigestellt ist, damit die Werte auch zu sehen sind lächeln (Grafikstart löscht Bildschirm)

Grafik initialisieren
tja, hier hab ich lange rumgeknausert, wollte einfach selbst bestimmen, welche Grafik einzustellen ist. Das ist bei Allegro so nicht geplant. Sondern, man gibt den Wunsch einer Auflösung an und Allegro versucht so nahe wie möglich an den Wunsch heranzukommen.
Jetzt mal im Einzelnen:
die Befehlsfolge dazu lautet:
set_color_depth(bitsZahl)
set_gfx_mode(Modus, Breite, Hoehe, virtuellBreit, virtuellHoch)

Also zuerst den Farbtiefenwunsch als Bits-Anzahl setzen (8 für 256Farben, oder 15, 16 24,32)
danach den Auflösungswunsch mit set_gfx_mode abfragen/setzen. Dabei gilt
Modus = GFX_AUTODETECT, GFX_AUTODETECT_FULLSCREEN, GFX_AUTODETECT_WINDOWED, GFX_SAFE oder GFX_TEXT
  • GFX_AUTODETECT stellt einen dem Wunsch am nächsten kommende Auflösung ein.
  • für GFX_AUTODETECT_FULLSCREEN gilt das gleiche, jedoch als Vollbildmodus, sofern möglich
  • bei GFX_AUTODETECT_WINDOWED als Fenster auf dem Desktop Ihres Betriebssystems.
  • GFX_SAFE versucht ebenfalls Ihrem Wunsch gerecht zu werden. Springt aber unter DOS auf 320x200xVGA und unter Windows auf 640x480 zurück, falls Ihr Wunsch nicht annähernd erfüllt werden kann.
  • GFX_TEXT ist die niedrigste Screeneinstellung, die sollte immer laufen: Textmodus mit 80Zeichen bei 25 Zeilen. Alle evtl. bereits geöffneten Grafikfenster werden geschlossen.

Breite, Hoehe = die wirkliche Breite und Hoehe der Bildschirmauflösung in Pixel
virtuellBreit, virtuellHoch = die gewünschte Größe des Virtuellen Screens in Pixel oder 0, 0 falls kein Virtueller Screen eingestellt werden soll.Im Moment brauchen wir das auch nicht, also geben wir Virtuell mit 0,0 an.

Die Funktion set_gfx_mode gibt wieder einen Wert zurück, ist dieser 0(NULL) ist alles OK, ansonsten ist ein Fehler aufgetreten. Somit lautet der Aufruf für unseren Wunsch 640x480x8 unter Berücksichtigung der an unserer Funktion übergebenen Variablen: ScrBreite%, ScrHoehe%, ScrTiefe%
Code:
  'GRAFIKMODUS SETZEN
    set_color_depth(ScrTiefe%)
    IF (set_gfx_mode(GFX_AUTODETECT, ScrBreite%, ScrHoehe%, 0, 0) <> 0) THEN
      'Grafikmodus nicht gesetzt, Fehler!
      ReturnWert%=-2
      'Textmodus setzen
      IF (set_gfx_mode(GFX_TEXT, 0, 0, 0, 0) <> 0) THEN
        ReturnWert%=-3
        allegro_message("Es konnte weder Grafikmodus noch Textmodus gestartet werden")
        GOTO AllegroEnde
      END IF
      allegro_message("Es konnte kein Grafikmodus gestartet werden, Textmodus laeuft!")
      GOTO AllegroEnde
    END IF

Anmerkung: allegro_message immer dann als Textanzeige verwenden, wenn nicht genau geklärt ist, was für ein Modus (Grafik/Text/?) in Allegro laeuft. Unter manchen Betriebssystemen wird diese message im Programmfenster angezeigt, unter anderen wird eine Message-Box zum OK-Klicken geöffnet.

Allegro Tastaturtreiber starten
Achten Sie immer darauf, daß ZUERST ein Grafikmodus eingestellt wird und DANACH der Tastaturtreiber gestartet wird! Der Befehl um den Tastaturtreiber von Allegro zu starten heißt: install_keyboard und bringt auch einen Rückgabewert. Ist dieser 0 (NULL), dann ist der Treiber installiert, ansonsten war ein Fehler aufgetreten.
Code:
  'TastaturTreiber Starten
  IF install_keyboard <> 0 THEN
    TEXT_Zentriert("Tastaturtreiber-install fehlgeschlagen",255)
    GOTO Programmende
  ELSE
    Text_Zentriert("Tastaturtreiber gestartet",255)
  END IF

DENKEN SIE DARAN, nachdem der Allegro-TastaturTreiber isnstalliert ist, funktioniert der FreeBasic-Treiber (Inkey$ etc) NICHT MEHR.



Text unter Allegro-Grafik
Ja, jetzt sind wir soweit. Allegro ist gestartet, und ein Grafikmodus ist eingestellt. Ab jetzt können wir Texte ausgeben, die im Grafikmodus zu sehen sind. Also bauen wir jetzt eine Anzeige, die den Ablauf des Allegro-Starts anzeigt.

Hintergrund und die Variable 'Screen'
Damit bezüglich der Farbgebung/Lesbarkeit sicher sind, setzen wir erst mal einen Schwarzen Hintergrund. Dazu der Befehl:
clear_to_color (screen, Farbe)
wobei anzumerken ist, Allegro geht davon aus, daß die Variable screen auf eine Bitmap-Struktur mit Palette zeigt. Und genau so ist auch die Anzeige Unter Allegro eingestellt, eine Bitmap-Struktur mit Palette. Verwenden Sie den Variablennamen screen in den Grafikbefehlen als Zieladresse, so landet Ihre Grafikanweisung schnurstraks auf dem Monitor, da Allegro diese Variable beim Grafik-Start bereits auf die Grafikanzeige initialisiert hat.
Als Farbe können Sie eine Farb-Nr der Palette angeben. Da meißtens Die Farb-Nr 0 einen schwarzen Farbwert enthält, verwenden wir diese Nummer
clear_to_color(screen, 0)

Texthoehe
Textausgaben unter Grafik erfolgen mit einer Pixel-Positionsangabe. Somit haben wir uns um Zeilenabstände und Zeilenwechsel selber zu kümmern. Entsprechend brauchen wir vor allem die Höhe der Schrift in Pixel, um eine zweite/nächste Zeile mit richtigem Abstand unter die vorige Zeile zu schreiben. Unter Allegro hierzu ein kurzer, knapper Befehl: text_height(font). Die Variable font ist von Allegro bereits initialisiert und zeigt auf den aktuellen Anzeigefont.

Text
wird mit den Befehlen:

  1. textout(screen, font, Text$, PosX, PosY, Farb-Nr) erzeugt linksbündig geschriebener Text, (wie der FreeBasic-PRINT-Befehl)
  2. textout_centre(screen, font, Text$, PosX, PosY, Farb-Nr) erzeugt zentrierten Text, die Mitte des Textes liegt bei den PosX-PosY-Angaben
  3. textout_right(screen, font, Text$, PosX, PosY, Farb-Nr) erzeugt rechtsbündigen Text, das Ende des Textes liegt auf den PosX-PosY-Angaben

angezeigt. Es gibt noch mehr Befehle dazu in Allegro, diese reichen aber erst mal als Einführung
  • screen ist bereits mit den Werten zur Grafikanzeige belegt und wird einfach so hier verwendet, sodaß der Text direkt auf dem Monitor angezeigt wird.
  • font ist ebenfalls von Allegro bereits vorbelegt, wir merken uns hier nur, man könnte die Schriftart auch verändern (muß diese aber irgendwie erst erzeugen)
  • Text$ ein Textstring, der angezeigt werden soll
  • PosX horizontale Position des Textes in Pixel
  • PosY vertikale Position des Textes in Pixel
  • Farb-Nr aus der Palette. In dieser Farbe wird der Text ausgegeben

Da wir nur ein paar einzelne Info-Zeilen ausgeben wollen, erzeugen wir zur Textanzeige eine eigene Sub-Routine, die selbstständig zentrierten Text in der Bildschirmmitte anzeigt und selbstständig auch die Zeilenschaltung durchführt.
Die Zeilenschaltungsautomatik erzeugen wir über eine Variable, die wir im Hauptteil als SHARED dimmen, sodaß in sämtlichen SUBs/FUNCs diese Variable zur Verfügung steht und auch nach verlassen der Textanzeigesub den Wert nicht verliert.
Code:
DIM SHARED ZeilenYPos%
DECLARE SUB TEXT_Zentriert(AnzeigeText$, TextFarbNr%)
im Hauptteil des Programmes am Anfang setzen
Ergänzend noch die Befehle: acquire_screen() und release_screen().
Man muß diese beiden Befehle nicht unbedingt angeben, aber auf vielen Systemen kann man die Anzeigegeschwindigkeit erhöhen, indem man vor einer Anzeige acquire_screen() setzt und danach mittels release_screen() dies wieder aufhebt. Am stärksten macht sich der Geschwindigkeitsvorteil bemerkbar, wenn sie mehrere Grafikbefehle zwischen acquire_screen() und release_screen() setzen. Bedenken Sie aber, daß zwischen diesen beiden Befehlen keinerlei Tastatureingaben angenommen werden und auch einige andere Systembefehle nicht laufen. Also immer rechtzeitig ein release_screen() setzen.
und die
Code:
SUB TEXT_Zentriert(AnzeigeText$, TextFarbNr%)
   acquire_screen()
     ScreenMitte% = SCREEN_W\2  :'SCREEN_X = Anzeigebreite von Allegro erstellt, \2 = mitte
     textout_centre(screen,font,AnzeigeText$, ScreenMitte%, ZeilenYPos%, TextFarbNr%)
     ZeilenYPos%=ZeilenYPos% + text_height(font) :'=Zeilenschaltung in Font-Höhe
   release_screen()
END SUB
erstellen.

Die Infos aus Allegro_init als Text ausgeben
OK. Wir haben eine Textanzeigeroutine und bereits einige Infos durch Allegrostart, die es auszugeben gilt. Fangen wir an.
Zuerst die Variablen, die durch Allegro_init erstellt wurden:
Code:
TEXT_Zentriert(allegro_id + " gestartet", 255) :'Allegro Version in weiß ausgeben

mit der os_type muß erst aufgeschlüsselt werden, was gemeint ist. In os_type ist nur eine Nummer drin, anhand von folgendem Code können Sie den Schlüssel auswerten:
Code:
      'Info Betriebssystem Anzeigen
      IF os_type=OSTYPE_UNKNOWN THEN dummy$="unbekannt oder reines MSDOS"
      IF os_type=OSTYPE_WIN3    THEN dummy$="Windows 3.1 oder zuvor"
      IF os_type=OSTYPE_WIN95   THEN dummy$="Windows 95"
      IF os_type=OSTYPE_WIN98   THEN dummy$="Windows 98"
      IF os_type=OSTYPE_WINME   THEN dummy$="Windows ME"
      IF os_type=OSTYPE_WINNT   THEN dummy$="Windows NT"
      IF os_type=OSTYPE_WIN2000 THEN dummy$="Windows 2000"
      IF os_type=OSTYPE_WINXP   THEN dummy$="Windows XP"
      IF os_type=OSTYPE_OS2     THEN dummy$="OS/2"
      IF os_type=OSTYPE_WARP    THEN dummy$="OS/2 Warp 3"
      IF os_type=OSTYPE_DOSEMU  THEN dummy$="Linux DOSEMU"
      IF os_type=OSTYPE_OPENDOS THEN dummy$="Caldera OpenDOS"
      IF os_type=OSTYPE_LINUX   THEN dummy$="Linux"
      IF os_type=OSTYPE_SUNOS   THEN dummy$="SunOS/Solaris"
      IF os_type=OSTYPE_FREEBSD THEN dummy$="FreeBSD"
      IF os_type=OSTYPE_NETBSD  THEN dummy$="NetBSD"
      IF os_type=OSTYPE_IRIX    THEN dummy$="IRIX"
      IF os_type=OSTYPE_QNX     THEN dummy$="QNX"
      IF os_type=OSTYPE_UNIX    THEN dummy$="Unbekannter Unix-Ableger"
      IF os_type=OSTYPE_BEOS    THEN dummy$="BeOS"
      IF os_type=OSTYPE_MACOS   THEN dummy$="MacOS"
      IF os_version > 0 THEN dummy$=dummy$+"   Version: ";os_version;
      IF os_revision > 0 THEN dummy$=dummy$+"   Revision: ";os_revision;
      IF os_multitasking = TRUE THEN
         dummy$=dummy$+"   Multitasking vorhanden"
      ELSE
         dummy$=dummy$+"   kein Multitasking"
      END IF
      'nachdem nun in der Variablen dummy$ der Text zum Betriebssystem zusammengebastelt ist,
      'kann dieser angezeigt werden:
      TEXT_Zentriert("Betriebssystem:"+dummy$,255)
Damit hätten wir die Variablen aus Allegro_init angezeigt. Jetzt kommen die Infos zur eingestellten Grafik:

Die Infos aus Grafik-Start als Text ausgeben
In den Variablen SCREEN_W und SCREEN_H hat Allegro bereits die Breite und die Höhe der eingestellten Grafik abgespeichert. Die Farbtiefe muß mit einer Funktion von Allegro erfragt werden. Diese lautet: bitmap_color_depth(BITMAP *bmp). Soll heißen, hole Bitmap-Tiefe aus einer Bitmap-Struktur. Und die Anzeige(screen pointet darauf) ist ja unter Allegro eine Bitmap-Struktur. Somit erhalten wir die tatsächlich eingestellte Farbtiefe mittels: bitmap_color_depth(screen) also basteln wir uns wieder einen Anzeigestring in Dummy$ und zeigen diesen an:
Code:
'Textausgabe zur aktuellen Grafikeinstellung
dummy$="Grafik-Einstellung:  "
dummy$=dummy$+"Breite="+STR$(SCREEN_W)
dummy$=dummy$+" X Hoehe="+STR$(SCREEN_H)
dummy$=dummy$+" X Tiefe(bits)="+STR$(bitmap_color_depth(screen))
TEXT_Zentriert(dummy$,255)

Zum Schluß von StartAllegro können wir noch etwas Bauernschläue einbauen.
Wir prüfen ob die gewünschte Auflösung und Farbtiefe dem entspricht, was Allegro schlußendlich eingestellt hat und melden dies entsprechend per Textanzeige:
Code:
'Prüfen ob Allegro exakt die Grafik eingestellt hat, die gefordert war
'und entsprechenden Text ausgeben
IF (ScrTiefe%=bitmap_color_depth(screen)) AND (ScrBreite%=SCREEN_W) AND (ScrHoehe%=SCREEN_H) THEN
  TEXT_Zentriert("Allegro hat die gewuenschte Aufloesung eingestellt",255)
ELSE IF ScrTiefe% <> bitmap_color_depth(screen) THEN
  TEXT_Zentriert("Allegro hat eine andere Farbtiefe eingestellt",255)
ELSE IF ScrBreite%<>SCREEN_W THEN
  TEXT_Zentriert("Allegro hat eine andere Breite der Aufloesung eingestellt",255)
ELSE IF ScrHoehe%<>SCREEN_H THEN
  TEXT_Zentriert("Allegro hat eine andere Hoehe der Aufloesung eingestellt",255)
ENDIF


evtl. Fehler von Allegro auswerten
So, die Function für den Allegrostart ist nun erst mal komplett. Was jetzt noch fehlt, ist die Auswertung der eventuell beim Allegro-Start aufgetretenen Fehler und entsprechenden Reaktionen. In der SUB Allegro_Starten hatten wir ja an den entscheidenden Stellen mittels unserer Variable ReturnWert% negative Fehlerwerte festgelegt und am Ende der SUB in die Funktionsrückgabenvariable Allegro_starten% übertragen. Somit müssen wir nur noch im Hauptteil unseres Programmes diese Rückgabe auswerten. Das machen wir über eine IF Abfrage, ob Allegro_starten% im Minus liegt, und innerhalb dieser IF-Schleife dann mittels Select Case auf die einzelnen Fehler eingehen.
Code:
'Auf eventuelle Fehler durch Allegro_Starten eingehen
IF Erfolg% < 0 THEN
  'in Allegro_Starten ist ein Fehler aufgetreten
  SELECT CASE Erfolg%
    CASE -1
       'allegro_init ist fehlgeschlagen, kein Allegro greifbar
       GOTO Programmende
    CASE -2
       'set_gfx_mode ist fehlgeschlagen, nur Textmodus da
       GOTO Programmende
    CASE -3
       'set_gfx_mode als Textmodus auch fehlgeschlagen
       GOTO Programmende
    CASE ELSE
       'Erfolg% ist negativ, also Fehler, aber keiner der
       'zuvor ausgewerteten. Haben Sie einen neuen Fehlerwert
       'in der Sub Allegro_starten eingefügt?
       GOTO Programmende
  END SELECT
END IF
'=============================================
'Auf Tastendruck warten
readkey()
' hier dazwischen könnte Ihr eigentliches
' Programm stehen, Allegro ist erfolgreich
' gestartet worden

'=============================================
Programmende:
allegro_exit()

Ich hab bei jedem Fehler einen Info-Text mit reingesetzt und grundsätzlich bei jedem Fehler das Programm Beendet.
Falls Sie z.B. bei fehlender Grafik aber ordentlichem Textmodus das Programm weiterlaufen lassen wollen, brauchen Sie ja nur die CASE -2 Rubrik entsprechend anpassen (kein Goto Programmende).

letzte Hinweise:
Nachdem der Grafikmodus von Allegro initialisiert ist, läuft Inkey$ von FreeBasic NICHT MEHR!
allegro_exit MUSS noch vor dem Programmende ausgeführt werden, achten Sie stets darauf!

Programmzusammenfassung:
Hier nun unser entwickeltes Programm an einem Stück:
Code:
'Allegro.Bas    Grundgeruest um Allegro in Freebasic einzubinden
'---------------------------------------------------------------
'Initialisierungsbereich
'=======================
'$include: 'inc\allegro.bi'
DECLARE FUNCTION Allegro_starten%(ScrBreite%, ScrHoehe%, ScrTiefe%)
DECLARE SUB TEXT_Zentriert(AnzeigeText$, TextFarbNr%)
DIM SHARED ZeilenYPos%
'
'Hauptteil
'=========
Erfolg% = Allegro_starten%(640, 480, 8)
IF Erfolg% < 0 THEN
  'in Allegro_Starten ist ein Fehler aufgetreten
  SELECT CASE Erfolg%
    CASE -1
       'allegro_init ist fehlgeschlagen, kein Allegro greifbar
       GOTO Programmende
    CASE -2
       'set_gfx_mode ist fehlgeschlagen, nur Textmodus da
       GOTO Programmende
    CASE -3
       'set_gfx_mode als Textmodus auch fehlgeschlagen
       GOTO Programmende
    CASE ELSE
       'Erfolg% ist negativ, also Fehler, aber keiner der
       'zuvor ausgewerteten. Haben Sie einen neuen Fehlerwert
       'in der Sub Allegro_starten eingefügt?
       GOTO Programmende
  END SELECT
END IF
'=============================================
'Auf Tastendruck warten
readkey()
' hier dazwischen könnte Ihr eigentliches
' Programm stehen, Allegro ist erfolgreich
' gestartet worden
'=============================================
Programmende:
allegro_exit()

'
'Unterprogramme
'==============
FUNCTION Allegro_starten%(ScrBreite%, ScrHoehe%, ScrTiefe%)
   ReturnWert%=0

   'Allegro-Init aufrufen und bei Fehler reagieren:
   IF (allegro_init() <> 0) THEN
     ReturnWert%=-1
     GOTO AllegroEnde
   END IF

  'GRAFIKMODUS SETZEN
    set_color_depth(ScrTiefe%)
    IF (set_gfx_mode(GFX_AUTODETECT, ScrBreite%, ScrHoehe%, 0, 0) <> 0) THEN
      'Grafikmodus nicht gesetzt, Fehler!
      ReturnWert%=-2
      'Textmodus setzen
      IF (set_gfx_mode(GFX_TEXT, 0, 0, 0, 0) <> 0) THEN
        ReturnWert%=-3
        allegro_message("Es konnte weder Grafikmodus noch Textmodus gestartet werden")
        GOTO AllegroEnde
      END IF
      allegro_message("Es konnte kein Grafikmodus gestartet werden, Textmodus laeuft!")
      GOTO AllegroEnde
    END IF

  'TastaturTreiber Starten
  IF install_keyboard <> 0 THEN
    TEXT_Zentriert("Tastaturtreiber-install fehlgeschlagen",255)
    GOTO Programmende
  ELSE
    Text_Zentriert("Tastaturtreiber gestartet",255)
  END IF

  TEXT_Zentriert(allegro_id + " gestartet", 255) :'Allegro Version in weiß ausgeben

  'Info Betriebssystem Anzeigen
  IF os_type=OSTYPE_UNKNOWN THEN dummy$="unbekannt oder reines MSDOS"
  IF os_type=OSTYPE_WIN3    THEN dummy$="Windows 3.1 oder zuvor"
  IF os_type=OSTYPE_WIN95   THEN dummy$="Windows 95"
  IF os_type=OSTYPE_WIN98   THEN dummy$="Windows 98"
  IF os_type=OSTYPE_WINME   THEN dummy$="Windows ME"
  IF os_type=OSTYPE_WINNT   THEN dummy$="Windows NT"
  IF os_type=OSTYPE_WIN2000 THEN dummy$="Windows 2000"
  IF os_type=OSTYPE_WINXP   THEN dummy$="Windows XP"
  IF os_type=OSTYPE_OS2     THEN dummy$="OS/2"
  IF os_type=OSTYPE_WARP    THEN dummy$="OS/2 Warp 3"
  IF os_type=OSTYPE_DOSEMU  THEN dummy$="Linux DOSEMU"
  IF os_type=OSTYPE_OPENDOS THEN dummy$="Caldera OpenDOS"
  IF os_type=OSTYPE_LINUX   THEN dummy$="Linux"
  IF os_type=OSTYPE_SUNOS   THEN dummy$="SunOS/Solaris"
  IF os_type=OSTYPE_FREEBSD THEN dummy$="FreeBSD"
  IF os_type=OSTYPE_NETBSD  THEN dummy$="NetBSD"
  IF os_type=OSTYPE_IRIX    THEN dummy$="IRIX"
  IF os_type=OSTYPE_QNX     THEN dummy$="QNX"
  IF os_type=OSTYPE_UNIX    THEN dummy$="Unbekannter Unix-Ableger"
  IF os_type=OSTYPE_BEOS    THEN dummy$="BeOS"
  IF os_type=OSTYPE_MACOS   THEN dummy$="MacOS"
  IF os_version > 0 THEN dummy$=dummy$+"   Version: " + STR$(os_version)
  IF os_revision > 0 THEN dummy$=dummy$+"   Revision: " + STR$(os_revision)
  IF os_multitasking = TRUE THEN
    dummy$=dummy$+"   Multitasking vorhanden"
  ELSE
    dummy$=dummy$+"   kein Multitasking"
  END IF
  'nachdem nun in der Variablen dummy$ der Text zum Betriebssystem zusammengebastelt ist,
  'kann dieser angezeigt werden:
  TEXT_Zentriert("Betriebssystem:"+dummy$,255)

  'Textausgabe zur aktuellen Grafikeinstellung
  dummy$="Grafik-Einstellung:  "
  dummy$=dummy$+"Breite="+STR$(SCREEN_W)
  dummy$=dummy$+" X Hoehe="+STR$(SCREEN_H)
  dummy$=dummy$+" X Tiefe(bits)="+STR$(bitmap_color_depth(screen))
  TEXT_Zentriert(dummy$,255)

  'Prüfen ob Allegro exakt die Grafik eingestellt hat, die gefordert war
  'und entsprechenden Text ausgeben
  IF (ScrTiefe%=bitmap_color_depth(screen)) AND (ScrBreite%=SCREEN_W) AND (ScrHoehe%=SCREEN_H) THEN
    TEXT_Zentriert("Allegro hat die gewuenschte Aufloesung eingestellt",255)
  END IF
  IF ScrTiefe% <> bitmap_color_depth(screen) THEN
    TEXT_Zentriert("Allegro hat eine andere Farbtiefe eingestellt",255)
  END IF
  IF ScrBreite%<>SCREEN_W THEN
    TEXT_Zentriert("Allegro hat eine andere Breite der Aufloesung eingestellt",255)
  END IF
  IF ScrHoehe%<>SCREEN_H THEN
    TEXT_Zentriert("Allegro hat eine andere Hoehe der Aufloesung eingestellt",255)
  END IF

AllegroEnde:
   Allegro_starten%=ReturnWert%
END FUNCTION

SUB TEXT_Zentriert(AnzeigeText$, TextFarbNr%)
   acquire_screen()
     ScreenMitte% = SCREEN_W\2  :'SCREEN_X = Anzeigebreite von Allegro erstellt, \2 = mitte
     textout_centre(screen,font,AnzeigeText$, ScreenMitte%, ZeilenYPos%, TextFarbNr%)
     ZeilenYPos%=ZeilenYPos% + text_height(font) :'=Zeilenschaltung in Font-Höhe
   release_screen()
END SUB

dieses Beispielprogramm hab ich erfolgreich unter folgenden Systemen getestet:
    PC/ System /Compiler
  • P200MMX / MSDOS7 / FreeBasic0.14DOS
  • P200MMX / MSDOS7 / FreeBasic0.15DOS
  • P200MMX / W98SE / FreeBasic0.14DOS
  • P200MMX / W98SE / FreeBasic0.15DOS
  • P200MMX / W98SE / FreeBasic0.14Windows
  • P200MMX / W98SE / FreeBasic0.15Windows
  • P200MMX / W98SE / FreeBasictesting0.16Windows
  • AMD2700 / WinXP / FreeBasic0.14DOS
  • AMD2700 / WinXP / FreeBasic0.15DOS
  • AMD2700 / WinXP / FreeBasic0.14Win
  • AMD2700 / WinXP / FreeBasic0.15Win
  • AMD2700 / WinXP / FreeBasictesting0.16Windows

_________________
Kaum macht mans richtig, schon geht's


Zuletzt bearbeitet von Eastler_dart am 27.02.2006, 23:16, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
Eastler_dart



Anmeldungsdatum: 24.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 26.02.2006, 23:23    Titel: Allegro lernt deutsch und International Antworten mit Zitat


Allegro lernt deutsch und international
Version 26.Feb 2006 - Eastler_Dart

Achten Sie Stets auf die Version, falls ich neue Erkenntnisse erlange, werde ich hier per EDIT das Tutorial ändern und entsprechend das Versionsdatum anpassen.

Tja, manche Sachen sind ganz einfach, wenn man herausgefunden hat, wie es geht.

Hab ewig gesucht, wie ich dem Allegro-Tastaturtreiber beibringen kann, daß er ein "Ä" meldet, wenn die Taste "Ä" gedrückt wird. Auch ein Anzeigen eines Textes, in dem ein "ä" vorkommt, ging erst mal nicht.

Dabei ist Allegro international zu allem fähig - ich dummerle.

So gehts:
Einfach in das Verzeichnis, in dem Ihre kompillierte MeinProg.exe steht, folgende Dateien reinkopieren:
1) Keyboard.dat
2) Language.dat
3) allegro.cfg

Danach die allegro.cfg (ist eine reine Textdatei) editieren, falls Sie etwas anderes, als deutsch einstellen wollen (Frankreich? Schweiz? .... die Liste ist lang, hab sie vollständig als kommentar in allegro.cfg reingetippt)

Wichtig: diese Daten werden nicht in Ihr Programm mit reincompiliert!
Sondern beim Starten Ihres Programmes sucht der Allegro-Teil im Programmverzeichnis nach diesen Dateien und stellt sich darauf ein, falls Allegro die Dateien findet.

Ergo: Wenn Sie Ihr Programm weiter geben, müssen immer diese Dateien dann mit dazu traurig

Vorteil: Der Nutzer Ihres Programmes braucht nur die allegro.cfg zu ändern (andere Länderkürzel rein) und schon hat er Buchstaben und Tastatur des Landes, was er sich wünscht.

Quelle: Da diese Dateien im Zip-Archiv von Allegro enthalten sind, ich jedoch Mühe hatte, diese Archive zu entpacken (mit uralt-entpacker, da die neueren alle meckerten), hab ich kurzerhand diese Dateien auf meiner Homepage zum Download zur Verfügung gestellt:
http://www.eastler.de/FreeBasic ....Ihr findet die dort schon lächeln

Zusatz: auf meiner Seite könnt ihr auch die De.cfg und Detexte.cfg zusätzlich downloaden.
Theoretisch (lt. Allegro-Tutorial) würde es ja reichen, diese beiden Dateien samt der allegro.cfg ins Programmverzeichnis zu setzen. Der User hat dann aber nicht die Möglichkeit, auf Französisch oder sonstwas umzustellen, weil Language.dat und Keyboard.dat dann fehlen, und in denen beiden die Daten für die restlichen Länder stehen.

Der Vorteil läge aber darin, in diesen Dateien Änderungen durchzuführen. z.B. läßt sich die De.cfg bequem editieren, da dies eine reine Text-Datei ist. In Ihr stehen pro Zeile eine Taste, und dahinter, welcher Ascii-Code an Allegro zu senden ist, wenn diese Taste gedrückt wird. Hier könnte man rumexperimentieren und auf bestimmte, ausgefallene Tasten die Chr$-Codes 1-31 für Sonderfunktionen legen. Das wäre aber erst auszutesten.

Viel Spaß mit internationalem Allegro wünscht .... Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
Michael Frey



Anmeldungsdatum: 18.12.2004
Beiträge: 2577
Wohnort: Schweiz

BeitragVerfasst am: 27.02.2006, 17:20    Titel: Antworten mit Zitat

Oh mein Gott geschockt.

Sieht echt gut aus, hab's aber nocht nicht genau gelesen.

Was noch gut wäre, ist eine genauere Angabe über die Vorteile von "Allegro", dann auch screen pset und line sind (theoretisch) Plattform übergreifent angelegt, vom Bug im Aktuellen FB abgesehen.

Zitat:
3)in der Windows-(Linux?)-Version von FreeBasic in dem Verzeichnis, in dem Sie ihre compilierte MeinProg.EXE starten, die Datei alleg40.dll

Mach das Linux weg, Programme haben auf Linux nicht die Endung .exe und Biblitoheken haben nicht die Endung .dll
Leider hab ich zuwenig Ahnung von Linux um es genauer zu korrigieren.
_________________
http://de.wikibooks.org/wiki/FreeBasic Jede Hilfe für dieses Buch ist Willkommen!
http://de.wikibooks.org/wiki/FreeBasic:_FAQ FAQ zu Freebasic (im Aufbau, hilfe Willkommen)
Neu mit Syntax Highlight
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Eastler_dart



Anmeldungsdatum: 24.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 28.02.2006, 00:15    Titel: Allegro stellt Fragen - Eingaben Antworten mit Zitat


Allegro stellt Fragen - Eingaberoutine-tutorial - Version 27.Feb 2006 - Eastler_Dart
Achten Sie Stets auf die Version, falls ich neue Erkenntnisse erlange, werde ich hier per EDIT das Tutorial ändern und entsprechend das Versionsdatum anpassen.


Vorwort
Wenn man vom Gesamtbild von Allegro ausgeht, bräuchten wir das eigentlich nicht selber machen. Es sind ettliche vorgefertigte Objekte in Allegro integriert. Compiliert mal die Beispiele, die FreeBasic im Verzeichnis examples/Allegro mitbringt, haut die alleg40.dll mit da rein und startet diese dann (wenn ihr unter Windows seid zwinkern). Da kann man erahnen, was alles möglich ist. Grad speziell zu dem Thema hier ist das Beispiel "dialog.bas" interessant. Es zeigt ein großes Farbfeld und drei "Schieberegler" dazu. Mit diesen Reglern (Slider) können stufenlos die Rot- Grün- und Blauanteile dieses Farbfeldes stufenlos verstellt werden. Alles mit ein paar wenigen Zeilen erstellt, weil die Schieberegler eben als fertige Objekte drin sind lächeln.

Nur die Optik dabei gefällt mir persönlich nicht wirklich. Auch wollen wir hier ein paar Beispiele zum Umgang mit Allegro zeigen.

Sicher Schieberegler wären nicht schlecht, aber zuerst muß ja mal was her, mit dem wir den Anwender um Eingaben bitten können, die Farben kommen erst später.

Was haben wir vor?
Ich biete Ihnen hier eine fertige Routine als FUNCTION, der Sie ein paar Parameter senden und schon erhält der Anwender ein Eingabefeld gezeigt, in dem er das notwendige eintippen / abändern kann.

Grundlagen
Beachten Sie den vorigen Beitrag, "Allegro lernt deutsch", sodaß Sie die richtigen Dateien mit in Ihrem Verzeichnis stehen haben.
Erst dann findet der Anwender den Punkt, das Komma und alles weitere auf seiner Tastatur dort, wo es sein sollte.
Aber ein Wermutstropfen bleibt:
Die Tastatur liefert jetzt zwar den ASCII-Code für ein ä oder Ö, wenn diese Tasten gedrückt werden, aber der Standard-Font in Allegro, den wir der Einfachheit halber erst mal verwenden, weiß nicht wie die deutschen Sonderzeichen öäüÖÄÜ und ß aussehen. In diesem Fall wird in unserem Beispiel nur ein ^ anstelle der Sonderzeichen angezeigt. das soll aber erst mal nicht weiter stören (später kommt noch eine Font-Routine hier dazu, wenn ich das schaffe zwinkern).

Zusatzbemerkungen:
Alles, was die Routine anzeigt, wird mit den sogenannten primitiven Grafikfunktionen (line draw etc) gemacht. Alles, was die Anzeige während der Eingabe betrifft, steht ganz am Ende der Routine, ein Umsetzen auf FreeBasic-Befehle (wenns nur für Linux und Windows sein soll) ist einfach möglich. (Ich warte immer noch darauf, daß FreeBasic unter DOS funktioniert, das Team ist hartnäckig am Bug-Fixen lächeln). Denken Sie aber in einem solchen Fall daran, daß Sie am Beginn der Routine die Tastenabfrage ebenfalls auf die FreeBasic-Befehle zurücksetzen!

So, wie diese Routine geschrieben ist, dient sie eher als Beispiel, sollte aber tatelos funktionieren.

Was damit (noch!) nicht geht, ist das einzelne Drücken der Strg- oder Alt- oder Groß- Tasten abzufragen (also die Alt-Taste ganz alleine, ohne ein Buchstabe dazu zu drücken). Der Allegro-Tastaturtreiber liefert zwar diese Daten, das wäre aber für den Anfang zu kompliziert gewesen. Zumal solche Funktionen nicht wirklich immer gebraucht werden. Cursortasten, Tabulator und Rücktaste werden selbstverständlich beachtet.

Wie binde ich das ein?:
Kopieren Sie nachfolgendes Listing von Input_a.bas in eine separate Datei, die ebenso benannt ist. Diese Datei stellen Sie dann in das Verzeichnis, in dem Sie aus dem ersten Post das Beispielprogramm stehen haben. Hier der Code von Input_a.bas:
Code:
FUNCTION SubEingabe$(Eingabe$, Einlang%, LocX%, LocY%, EingTCo%, EingBCo%,EingCbCo%,EingCuCo%)
'============================================================================
'Input_a.bas        Eastler       Februar 2006
'----------------------------------------------------------------------------
'BESCHREIBUNG:
'Frägt den Anwender nach einer Eingabe ab, sauber in einem begrenzten
'Feld, Entfernen/Einfügen Pos1/Ende Tab und Rücktaste werden unterstützt.
'Eingabe wird von Allegro-Tastaturtreiber geholt und mit Allegro
'Textanzeigeroutine angezeigt.
'----------------------------------------------------------------------------
'BEMERKUNGEN:
'Wenn Sie die Dateien De.cfg Detext.cfg und allegro.cfg mit Inhalt DE
'im selben Verzeichnis haben, wie das compilierte Programm
'werden die deutschen Umlaute Tastaturmäßig unterstützt.
'(oder die Dateien Tastatur.dat, Keyboard.dat mit allegro.cfg (wie zuvor))
'
'Jedoch benutzt die Anzeigeroutine von Allegro einen Font, in dem
'es keine deutschen Umlaute (äöüß...) gibt, und zeigt deshalb das
'Ersatzzeichen "^" dafür an.
'Um das zu Ändern, sollte man:
' 1) einen neuen Font erstellen
' oder
' 2) eine eigene Anzeigeroutine mit eigenem Font verwenden
'    (die sollte aber mit Allegro-Grafikroutinen den Text anzeigen)
'Diese Änderungen wären ganz am Ende dieser Funktion einzuarbeiten.
'----------------------------------------------------------------------------
'ÜBERGABEN:
'Eingabe$ = Inhalt, der verändert werden soll
'Einlang% = Maximale Länge der Eingabe
'LocX LocY  = Position (linke obere Ecke) des Eingabefeldes
'EingTCo% = Textfarbe
'EingBCo% = Hintergrundfarbe
'EingCbCo%=Cursorfarbe hellerer Hintergrund des Zeichenfeldes
'EingCuCo%=Cursorfarbe Strich unter Eingabestelle
'----------------------------------------------------------------------------
  FontW% = text_length(font,"M")  'Breite eines Zeichens in Pixel holen
  FontH% = text_height(font)      'Höhe einer Schriftzeile in Pixel holen
  IF Einlang% = 0 THEN Einlang% = LEN(Eingabe$) 'falls keine Längenangabe da ist
  'Falls erlaubte Eingabelänge größer Eingabe ist, mit Space anfüllen
  IF Einlang% > LEN(Eingabe$) THEN
    Eingabe$ = Eingabe$ + SPACE$(Einlang% - LEN(Eingabe$))
  END IF
  X% = 1  :'Positionszähler des EingabeCursors
  EingabeC$ = Eingabe$ 'eine Kopie der Übergabe, mit Kopie hier arbeiten, original erhalten
  GOSUB Anzeige

InTasteWarten:
  'Das Herzstück. Die Loop-Schleife, in der nach in$ der Code der Eingabe gelegt wird
  DO
   in$ = CHR$(readkey())   'Readkey gibt Tasten als ASCII-Code,
   IF ASC(in$)=0 THEN
      'wenn 0 als ASCII übergeben wurde, dann Sondertaste! über Key() abfragen
      'Key() = Array von 1 bis Key_Max, in allegro.bi deffiniert,
      'wobei jedes Feld mit seiner Laufnummer eine Taste bestimmt,
      'und als Eintrag True oder False hat, je nachdem ob Taste
      'gedrückt oder nicht.
      'Die Nummer ist aber SCAN-Code! (a und A ist die selbe Nummer/Taste!)
      FOR KeyNummer%=1 TO KEY_MAX
         IF KEY(KeyNummer%) THEN
            IF KeyNummer%=82 THEN in$=chr$(255)+"K" :'Cursor nach links
            IF KeyNummer%=83 THEN in$=chr$(255)+"M" :'Cursor nach rechts
            IF KeyNummer%=77 THEN in$=chr$(255)+"S" :'entfernen
            IF KeyNummer%=76 THEN in$=chr$(255)+"R" :'einfügen
            IF KeyNummer%=78 THEN in$=chr$(255)+"G" :'Pos 1
            IF KeyNummer%=79 THEN in$=chr$(255)+"O" :'Ende
         END IF
      NEXT KeyNummer%
   END IF
  LOOP WHILE in$ = "" 'OR ASC(in$) = 0

  'Je nachdem, was gedrückt wurde, reagieren
  SELECT CASE ASC(in$)
    CASE 13: '                        RETURN-TASTE
      SubEingabe$ = EingabeC$: WEG = 0
      Einlang% = 0
      EXIT SUB
    CASE 8:                           ' R?ck Taste ???
      IF X% > 1 THEN
        X% = X% - 1
        MID$(EingabeC$, X%) = MID$(EingabeC$, X% + 1)
        MID$(EingabeC$, Einlang%, 1) = " "
      END IF
    CASE 9:                           ' Tabulator?
      X% = X% + 8
    CASE 27:                          'Escape
      in$ = "": X% = X% - 1
      Eingabe$ = "Esc"
      EXIT SUB
    CASE 255: 'Sondertaste mit 2char-Code, vorne chr$(255)
          SELECT CASE RIGHT$(in$, 1)
             CASE "K": '****CURSOR LINKS****
                X% = X% - 1
             CASE "M" '****CURSOR RECHTS****
                X% = X% + 1
             CASE "S": '****Entf Taste****
                MID$(EingabeC$, X%) = MID$(EingabeC$, X% + 1)
                MID$(EingabeC$, Einlang%, 1) = " "
             CASE "R": '****Einf Taste****
               IF X% < Einlang% THEN
                  MID$(EingabeC$, X% + 1) = MID$(EingabeC$, X%)
               END IF
               MID$(EingabeC$, X%) = " "
             CASE "G": '****Pos1 Taste****
               X% = 1
             CASE "O": '****Ende-Taste****
               X% = Einlang%
          END SELECT
    CASE 1 TO 31
      'nur auffuehren, damit Eingaben < Chr$(32)
      'nicht in Case Else reingehen und dort dann nur noch
      ' "normale" Tasten angesprochen werden.
    CASE ELSE: 'jede andere "normale" Taste
      MID$(EingabeC$, X%, 1) = in$
      X% = X% + 1
    END SELECT
    IF X% < 1 THEN X% = Einlang%
    IF X% > Einlang% THEN X% = 1
    GOSUB Anzeige
    GOTO InTasteWarten

Anzeige:
        text_mode(-1)  'Modus für Textanzeige setzen:
                       'Hier -1, damit transparent geschrieben wird
                       'es kann auch eine Farbnummer angegeben werden,
                       '   die als Hintergrund zu zeigen ist
                       '   z.B.: text_mode(22)  = grauer Hintergrund
        T$ = EingabeC$
        X1% = LocX%
        Y1% = LocY%
        X2% = X1% + LEN(T$) * FontW%
        Y2% = Y1% + FontH%
        'Hintergrund
        rectfill(screen, X1%, Y1%, X2%, Y2%, EingBCo%)
        'Cursor als Hellerer Hintergrund
        XC1% = LocX% + (X% - 1) * FontW%
        XC2% = XC1% + FontW%
        rectfill(screen, XC1%, Y1%, XC2%, Y2%, EingCbCo%)
        'den Text der Eingabe anzeigen
        'mit textout wird der interne Font verwendet,
        'der kennt keine äöüß...  zeigt stattdessen "^"
        textout(screen,font,T$, X1%, Y1%, EingTCo%)
        'Cursor unter Eingabeposition
        X1% = LocX% + (X% - 1) * FontW%
        X2% = X1% + FontW%
        Y1% = LocY% + FontH% - 1
        LINE(screen, X1%, Y1%, X2%, Y1%, EingCuCo%)
  RETURN
END FUNCTION

So, daß war der erste Schritt. Nun muß daß Ganze noch per include in das Beispielprogramm aus dem ersten Post integriert werden. Dazu fügen Sie die Zeile: '$include: 'input_a.bas' am Ende des Initialisierungsbereiches ein, wie im folgenden Code-Schnipsel das zu sehen ist:
Code:
'Initialisierungsbereich
'=======================
'$include: '..\..\inc\allegro.bi'
DECLARE FUNCTION Allegro_starten%(ScrBreite%, ScrHoehe%, ScrTiefe%)
DECLARE SUB TEXT_Zentriert(AnzeigeText$, TextFarbNr%)
DIM SHARED ZeilenYPos%
'$include: 'input_a.bas'
'
'Hauptteil
'=========


Und nun noch ein bißchen Beispielcode, der die Routine verwendet. Ich hab zur optischen Aufwertung und zur Dokumentation von Allegro-Grafikbefehlen gleich ein simples Meldefenster angedeutet. Dieses Fenster merkt sich auch den Screen-Bereich, den es verdecken wird, und restauriert nach der Eingabe gleich diesen Bereich wieder. Auch sowas ist unter Allegro sehr einfach zu bewerkstelligen zwinkern. Hoffe, die (vielen?) Kommentare im Quelltext helfen Ihnen, das ganze zu verstehen.

Hier also der Ausschnitt aus unserem ersten Beispielprogramm von "Auf Taste Warten" bis "Programmende:", mit den Zusätzlichen Einträgen der beispielhaften Verwendung der Eingaberoutine:
Code:
readkey()   'Auf Tastendruck warten, Infos lesen
' ab hier könnte Ihr eigentliches Programm stehen,
' Allegro ist erfolgreich gestartet worden
'
'---------------------------------------------------------------------------------------
'ein blaues Rechteck als Hintergrund erstellen:
HgX1%=50     'Positionsdaten des Rechtecks
HgX2%=360    'über Variablen deffinieren,
HgY1%=190    'sodaß diese Daten für die
HgY2%=300    'Schatten- und Glanzlinen ebenfalls zur Verfügung stehen
'    ---------------------------------------------------------------------------------------
'    Den Bereich auf dem Monitor, den dieses Rechteck überdecken wird, erst mal sichern
     'eine Bitmap im Ram erzeugen, in die eine Kopie reingestellt werden kann:
     ' Allegro-Befehlsbeschreibung:   create_bitmap(int width, int height)
     DIM KopieAdresse AS BITMAP PTR
     KopieAdresse = create_bitmap(HgX2%-HgX1%+1  , HgY2%-HgY1%+1)
     'alles da reinkopieren
     ' Allegrobeschreibung: blit(BITMAPsource, BITMAPdest, source_x, source_y, dest_x, dest_y, width, height);
     blit(screen, KopieAdresse, HgX1%, HgY1%, 0, 0, HgX2%-HgX1%+1, HgY2%-HgY1%+1)
'    ---------------------------------------------------------------------------------------

rectfill(screen, HgX1%, HgY1%, HgX2%, HgY2%, 3)
' ein paar Schattenlinen außen drum rum:
line(screen, HgX1%, HgY1%, HgX2%, HgY1%, 11)  'oben in Farbe 11 = hellblau  (Glanz)
line(screen, HgX1%, HgY1%, HgX1%, HgY2%, 11)  'links in Farbe 11 = hellblau (Glanz)
line(screen, HgX2%, HgY1%, HgX2%, HgY2%,196)  'rechts in Farbe 9 = dunkelblau (Schatten)
line(screen, HgX1%, HgY2%, HgX2%, HgY2%,196)  'unten in Farbe  9 = dunkelblau (Schatten)
'---------------------------------------------------------------------------------------
'Eingaberoutine input_a.bas verwenden:
Eingabe$="bisherige Eingabe"   'Bisheriger Inhalt, der per Input zu verändernden Variable
Einlang%=20                    'Eingabe auf 20 Zeichen begrenzen.
'                              'max-Grenzen= max-Länge eines Strings und Bildschirmbreite
LocX%=100                      'Positionsangabe X des Eingabefeldes (links oben)
LocY%=240                      'Positionsangabe Y des Eingabefeldes (links oben)
EingTCo%=   16                 'FarbNr (Schwarz?) in der der EingabeText angezeigt wird
EingBCo%=   11                 'HintergrundfarbNr (hellblau?)
EingCbCo%=  15                 'Hintergrundfarbe an Cursorposition (weiß?)
EingCuCo%=  15                 'Cursor_Unterstrich_Farbe (weiß ?)
'  ---------------------------------------------------------------------------------------
'    ein paar Schatten-/Glanz-linen um das Eingabefeld drum rum:
   Breite% = text_length(font,STRING$(Einlang%," "))  'Allegro, sag mir, wie breit der Text 20xSpace in Pixel ist
   Hoehe%  = text_height(font)                        'Allegro, sag mir, wie hoch eine Textzeile in Pixel ist
   rectfill(screen, LocX%-2,     LocY%-2,        LocX% + Breite%+2, LocY%+Hoehe%+2,EingBCo%)'EingabeFeld um 1 pixel größer
   line(screen, LocX%-2,         LocY%-2,        LocX% + Breite%+2, LocY%-2,       196)  'oben in Farbe  Schatten
   line(screen, LocX%-2,         LocY%-1,        LocX%-2,           LocY%+Hoehe%+1,196)  'links in Farbe Schatten
   line(screen, LocX%+Breite%+2, LocY%-1,        LocX% + Breite%+2, LocY%+Hoehe%+1, 15) 'rechts in Farbe Glanz
   line(screen, LocX%-2,         LocY%+Hoehe%+2, LocX% + Breite%+2, LocY%+Hoehe%+2, 15) 'unten in Farbe  Glanz
'  ---------------------------------------------------------------------------------------
'und jetzt der Eigentliche Aufruf der Anwenderabfrage, das Ergebnis landet in der Var Eingabe$
Eingabe$ = SubEingabe(Eingabe$, Einlang%, LocX%, LocY%, EingTCo%, EingBCo%,EingCbCo%,EingCuCo%)
     '------------------------------------------------------------------------------------
     ' und nun den Bildschirm wieder herstellen = Eingabefeld wieder weg
     ' Allegrobeschreibung: blit(BITMAPsource, BITMAPdest, source_x, source_y, dest_x, dest_y, width, height);
     blit(KopieAdresse, screen, 0, 0, HgX1%, HgY1%, HgX2%-HgX1%+1, HgY2%-HgY1%+1)
     'und den Ram, den die Kopie des Screens belegt hat, wieder freigeben
     destroy_bitmap(KopieAdresse)
     '------------------------------------------------------------------------------------
'Das ergebnis der Eingabe Anzeigen
TEXT_Zentriert(" ", 255)  'Leerzeile
TEXT_Zentriert(Eingabe$, 255) 'Eingegebene Daten anzeigen


'auf Tastendruck warten, dann Programmende
readkey()
'=========================================================
Programmende:


und nun?
Da jezt die geänderte "Grundpro.bas" oder wie Sie das Programm auch immer benannt haben, gespeichert ist, und auch die "input_a.bas" im gleichen Verszeichnis steht, brauchen wir nur noch die "Grundpro.bas" compilieren. Die "input_a.bas" wird ja per include automatisch mit reincompiliert, dafür ist nicht s weiter notwendig. Starten Sie die "Grundpro.exe", und studieren Sie den Quelltext dazu.

Was geht da ab?
Das Programm startet Allegro, und gibt ggf. Fehlermeldungen aus, wenn das nicht funktionieren sollte, genau so, wie wir das im ersten Post erstellt hatten.
An dieser Stelle wartet das Programm auf einen Tastendruck, damit Sie die Anzeigen auch in Ruhe lesen können.

Nach diesem Tastendruck wird sofort das Eingabefeld anzezeigt, in dem Sie nach Herzenslust eingeben können.

Wenn Sie die Eingabe mit Return beenden, wird das Eingabefeld geschlossen, Ihre Eingabe wird oben angezeigt.

Nach dem nächsten Tastendruck beendet sich das Programm.

Happy Inputting - Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
raph ael



Anmeldungsdatum: 12.04.2006
Beiträge: 472

BeitragVerfasst am: 11.06.2006, 17:46    Titel: Antworten mit Zitat

Super Tutorial!!
_________________
Zitat:
1000 Yottabytes sind absurd. 640 Yottabytes sollten genug für jeden sein.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Eastler_dart



Anmeldungsdatum: 24.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 15.03.2008, 21:08    Titel: Allegro gibt Toene von sich Antworten mit Zitat


Allegro gibt Toene von sich - vom 15.März 2008 - Eastler_Dart
Achten Sie Stets auf die Version, falls ich neue Erkenntnisse erlange, werde ich hier per EDIT das Tutorial ändern und entsprechend das Versionsdatum anpassen.


Hallo Leute,
nachdem ich eine Zeit lang nicht zum proggen gekommen bin, konnte ich mich jetzt wieder dem Hobby widmen.
Yoah, FB-Dos laeuft jetzt viel besser, die Grafik geht - freu.
Aber Musik oder ähnliches - hm.
Bei fbmod gibts Irgendwelche copyright-Bedingungen, glaub, ist nur fuer privates Hobby frei, oder so ähnlich
bass läuft noch nich auf Linux (aber bald?)

Jedenfalls, ist Allegro wiedermal nach vorne gerutscht, weil es schlichtweg fuer alle Einsaetze freigegeben ist, unter Dos unter Windows und unter Linux laeuft.

Also ganz mutig rangetreten und reingeackert.

Mit folgendem Listing hab ich bei mir Wavedateien abgespielt lächeln
Code:

'Allegro.Bas    Grundgeruest um Allegro in Freebasic einzubinden
' HIER DER VERSUCH, MUSIK (16-bit stereo Wave ist maximum) abzuspielen
'===============================================================
'Initialisierungsbereich
'---------------------------------------------------------------
#include once "allegro.bi"
DECLARE SUB TEXT_Zentriert(AnzeigeText AS STRING, TextFarbNr AS INTEGER)
'---------------------------------------------------------------
DIM SHARED AS INTEGER ZeilenYPos, Erfolg, ReturnWert, SchleifenZahl
DIM AS INTEGER Taste, SchleifenFlag
DIM AS STRING Dummy, Initfehler, TasteS, SampleName
DIM AS SAMPLE PTR SampleZeiger
'
'---------------------------------------------------------------
'Starte Allegro
'---------------------------------------------------------------
'---------------------------------------------------------------
'Andere Subs Functions dazuladen
'---------------------------------------------------------------
'===============================================================
'Hauptteil
'---------------------------------------------------------------
IF allegro_init() <> 0 THEN Initfehler="Allegro_init" : GOTO Programmende
set_color_depth(16)
IF (set_gfx_mode(GFX_AUTODETECT, 800, 600, 0, 0) <> 0) <> 0 THEN Initfehler="set_gfx_mode" : GOTO Programmende
IF install_keyboard <> 0 THEN Initfehler="install_keyboard" : GOTO Programmende
IF install_sound(DIGI_AUTODETECT , MIDI_AUTODETECT , "unused") <> 0 THEN Initfehler="install_sound" : GOTO Programmende

TEXT_Zentriert("ALLES OK, install_sound lief fehlerfrei", 255)
'---------------------------------------------------------------
'Allegro ist nun da, es kann losgehen
TEXT_Zentriert("befinde mich auf:" & ALLEGRO_PLATFORM_STR & " alles ok", 255)

'HIER WIRD DER DATEINAME ZU DER WAVE-DATEI FESTGELEGT
SampleName = "mein_lied.wav"
TEXT_Zentriert("lade " & SampleName, 255)
SampleZeiger = load_wav(SampleName)
'              load_wav kann waves in mono oder stereo und jeweils in 8 oder in 16-bit laden
'                       somit fuehrt das laden von 24 oder noch mehr -bittigen waves zu Fehler ! !
'              Ich hab mit diesem Beispielprogramm 13 und 14MB große Waves getestet, es ging.
'              Denken Sie daran, daß mit der hier gezeigten Methode
'              das komplette Wave in den Ram geladen wird und entsprechend soviel Ram verbraucht!
'              Unter Allegro kann man noch mit Audiostreams arbeiten, wobei immer nur
'              ein Teil des Waves in den Ram geladen und abgespielt wird,
'              dann nachladen von Festplatte, während der Rest des vorigen Teils noch gespielt wird.
'              Da ich das aber noch nicht probiert hab, kann ich (noch?) nix dazu sagen.
IF SampleZeiger = 0 THEN Initfehler="laden " & SampleName : GOTO Programmende
TEXT_Zentriert("Sample ist auf " & STR(SampleZeiger) & " geladen, Taste = abspielen.....", 255)
Taste = readkey()  :  ' auf Tastendruck warten = auf Anwender warten :-)


'          Deffinition:    play_sample(SampleZeiger, int vol, int pan, int freq, int loop)
'                   wobei: SampleZeiger = is klar, der pointer auf das geladene Sample
'                          int vol      = Integerwert 1-255 fuer Lautstaerke
'                          int pan      = Integerwert Stereo-Position
'                                         0 = ganz links  128=mitte  255=ganz rechts oder Zwischenwerte
'                          int Freq     = Integerwert Abspielfrequenz   1000 = in originaler Frequenz,
'                                         z.B. 2000 wäre doppelte Aabspielgeschwindigkeit/Mickey-Mouse-Effekt
'                          int loop     = Integerwert   0=einmal abspielen   1=staendig wiederholen
'                                         sollten Sie loopen, dann gibt es drei Möglichkeiten,
'                                         das endlos wiederholende Abspielen zu stoppen:
'                                              1) Programmende ruft ja allegro_exit() auf, das beendet alles
'                                              2) aus Ihrem Programm den Befehl: stop_sample(const SAMPLE *spl) ausführen
'                                                 damit wird das abspielen sofort gestoppt
'                                              3) mit dem Befehl:
'                                                 adjust_sample(const SAMPLE *spl, int vol, int pan, int freq, int loop)
'                                                 die Einstellungswerte einfach ändern, hier dann Loop auf 0
'                                                 dann wird das Sample noch fertig gespielt, danach ist aus
'                          Hinweis: mit adjust_sample(const SAMPLE *spl, int vol, int pan, int freq, int loop)
'                                   können waehrend dem Abspielen die Einstellungen weiterhin geändert werden

play_sample(SampleZeiger, 100, 128, 1000, 1)


text_zentriert(" ",255) :'Leerzeile
'---------------------------------------------------------------
TEXT_Zentriert("Taste druecken = Programmende", 255)
Taste=readkey()
TEXT_Zentriert("bitte Warten, beende Programm...", 255)

'---------------------------------------------------------------
Programmende:
allegro_exit()
IF Initfehler <> "" THEN
            PRINT "irgendwie war ein Fehler beim initialisieren in " & Initfehler & " in allegro_error steht: " & allegro_error
            INPUT "Return drücken", Dummy
            PRINT
END IF
PRINT "bitte Warten, beende Programm..."

'
'===============================================================
'Unterprogramme
'---------------------------------------------------------------
SUB TEXT_Zentriert(AnzeigeText AS STRING, TextFarbNr AS INTEGER)
   ' Damit kann ich einfach Texte in Allegro-Grafikfenster
   ' ausgeben, ohne mich um Anzeigepositionen kuemmern zu muessen.
   DIM AS INTEGER ScreenMitte
   acquire_screen()
     ScreenMitte = SCREEN_W\2  :'SCREEN_X = Anzeigebreite von Allegro erstellt, \2 = mitte
     textout_centre(screen,font,AnzeigeText, ScreenMitte, ZeilenYPos, TextFarbNr)
     ZeilenYPos=ZeilenYPos + text_height(font) :'=Zeilenschaltung in Font-Höhe
   release_screen()
END SUB
'---------------------------------------------------------------


Wie Ihr seht, lade ich nicht nur die Sound-Teile von Allegro, sondern auch Tastatur und Grafik mit dazu, weil ichs erstmal kompakt halten wollte. Irgendwie gehts bestimmt, nur den Soundteil zu verwenden und den Rest (Tastatur Grafik) von Freebasic ausführen zu lassen.

Jedoch bleibt ein Wermutstropfen:
Wie als Kommentar im Listing schon enthalten, kann allegro nur Waves und VOC-Dateien abspielen. Leider kein MP3 traurig

Bei den Waves wird auf 16-bit begrenzt. Aber das reicht mir dicke zu lächeln

Bei den VOC-Files duerfen es nur MONO-Dateien sein, kein Stereo traurig und ebenfalls maximal 16-bittig.

Kopiert das Listing, kompiliert es (FB 018.2), kopiert in das Verzeichnis, in dem die EXE dann steht noch die Allegro.dll (Version 4.0) sowie eine Wave-Datei, welche Ihr "mein_lied.wav" nennt, dann koennt Ihr die Exe starten.

Das Programm zeigt dann einen erfolgreichen Allegrostart an, nach Tastendruck wird euere Wav-Datei endlos wiederholt abgespielt. Sobald Ihr nochmal irgendeine Taste drueckt, wird der Sound und Programm beendet.



Hoffe, es hilft

euer Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
Jojo
alter Rang


Anmeldungsdatum: 12.02.2005
Beiträge: 9736
Wohnort: Neben der Festplatte

BeitragVerfasst am: 15.03.2008, 21:12    Titel: Re: Allegro gibt Toene von sich Antworten mit Zitat

Zitat:
bass läuft noch nich auf Linux (aber bald?)

Ian hat schon mehrfach zugesagt, sich "demnächst" um eine Linux-Version zu kümmern - Dieses Jahr könnt's sogar was werden lächeln
_________________
» Die Mathematik wurde geschaffen, um Probleme zu lösen, die es nicht gäbe, wenn die Mathematik nicht erschaffen worden wäre.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4594
Wohnort: ~/

BeitragVerfasst am: 16.03.2008, 16:23    Titel: Antworten mit Zitat

*vorfreu*
_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mao



Anmeldungsdatum: 25.09.2005
Beiträge: 4409
Wohnort: /dev/hda1

BeitragVerfasst am: 16.03.2008, 17:23    Titel: Antworten mit Zitat

Hast du evtl. Lust, die Tutorials auf FreeBASIC-Portal.de zu veröffentlichen? lächeln
_________________
Eine handvoll Glück reicht nie für zwei.
--
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eastler_dart



Anmeldungsdatum: 24.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 19.03.2008, 21:59    Titel: Antworten mit Zitat

@Mao erst mal: Klar doch
aber Ihr braucht euch bei meinen Posts keine "Urheberrechts"-Gedanken (welch schlimmes Word) zu machen. Ich hab hier und auch im Portal schon soviel Hilfe erhalten, daß mein Wissen, was ich hier reinstelle, jeder jederzeit überall helfend einsetzen kann, ohne mich zu fragen.
(boahh, bin doch kein Rechstanwalt)

@ALL
Zwischenergebnis zu dem Gedanken, per Allegro den Sound in FreeBasic zu verwenden, jedoch die Grafikfunktionen (besonders bei Älteren PCs bzw. mit noch langsamen AGP-1fach-oder-2fach-Karten) von Freebasic verwenden. HAB NOCH KEINEN VERNÜNFTIGEN WEG GEFUNDEN.
Sicher gehts, mit Allegro_init die Grundfunktionen starten, dann mit init_sound die Soundfunktionen einbinden (und sonst nix, kein set_gfx_mode oder install_keyboard oder ähnliches).
Mit dem zuvor beschriebenen load_wav eine Datei einlesen und mit play_sample dann abspielen.
Das komische dabei ist dann, mit dem install_sound will sich Allegro an ein Fenster anbinden und sucht scheinbar ein Allegro-Grafikfenster zum einklinken.
Findet dann aber keins, da wir ja auch keins gestartet haben, und öffnet kurzerhand einfach ein zusätzliches Fenster (in der Task-Leiste zu sehen, Größe scheinber 0x0 pix).
Ist dieses Fenster aktiv (klick drauf), dann hör ich die Wave-Datei, klick ich auf das Konsolenfenster oder das Grafikfenster von FB, ist alles still. klick ich wieder auf das 0x0-Fenster, hör ich die Wave wieder, sofern das abspielen noch nicht bis zum Ende gelaufen ist.
Beim Programm-beenden (hab ich beim Testen als Inkey-Tastendruck-warten erstellt) kommt im Grafikfenster die gewollte Anzeige "beende Programm", aber nix passiert, Fenster bleiben alle stehen.
Klick ich nun wieder in das 0x0pix-Fenster mit dem Sound, dann geht das beenden plötzlich los.

Würde mal vermuten, Sound über Allegro macht nur Sinn, wenn man auch gleich die Allegro-Grafik mit einbindet.

Hoffe es hilft

Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Bibliotheken Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.

 Impressum :: Datenschutz