====== Erste Schritte in Allegro ======

===== Kleinstes Allegro-Programm =====

So, nun haben wir hoffentlich eine funktionierende Allegrokonfiguration für unsere IDE.
Kommen wir nun zu den grundlegendsten Sachen, auf die kaum ein Allegro-Programm verzichten kann.

<code cpp>
#include <allegro.h>


int main()
{
        //Allegro einschalten
    if (allegro_init() != 0){
        exit(1);
    }

    //Grafik initialisieren
    set_color_depth(32);
    if (set_gfx_mode(GFX_AUTODETECT, 1024, 768, 0, 0) != 0) {
        set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
        allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
        _sleep(5000);
   }
   return 0;

}
END_OF_MAIN()
</code>


Kommen wir nun zur Erklärung des Codes.
Allegro muss initialisiert werden, dafür ist das Makro allegro_init() verantwortlich.

set_color_depth(32); legt fest, dass man bis zu 32 Bit pro Pixel benutzen kann, um Farbinformationen zu speichern. (Alternativ könnte man auch 16 oder 8 Bit verwenden, aber das wäre nicht sonderlich ansehnlich, und in der Regel schaffen Rechner, die nicht älter als 10 Jahre sind locker 32 Bit.)

set_gfx_mode() initialisiert den Bildschirm, damit Allegro damit arbeiten, also auf ihm "malen" kann. Das erste Argument gibt an, was man machen will - GFX_AUTODETECT sucht alles automatisch aus - danach kommt die Auflösung. Die letzten beiden
Parameter sind für die Auflösung des virtuellen Bildschirms, den wir aber hier nicht brauchen, deshalb wird sie auf 0x0 gesetzt.
Wenn irgendetwas schief geht, dann wird auf Textmodus gestellt und eine Warnung ausgegeben. Das sollte eigentlich immer funktionieren.

Im Allegromanual sind sämtliche GFX-Modes für [[http://alleg.sourceforge.net/stabledocs/en/alleg037.html#GFX_*/Windows|Windwos]] und [[http://alleg.sourceforge.net/stabledocs/en/alleg038.html#GFX_*/Linux|Linux]] zu finden.

Das Makro END_OF_MAIN() muss vorhanden sein, denn es erledigt unter Anderem eine ganze Menge #ifdef Aufrufe für uns und gewährleistet so Plattformunabhängigkeit.

Der Unterstrich bei _sleep() dient dazu Konflikte wie Namensüberschreitungen mit den Betriebssystem-APIs zu vermeiden. Deshalb liefert Allegro solche elementaren Sachen wie sleep mit -  in der allegro.h heißt es nur eben _sleep().

Und denkt dran gegen die liballeg.a bzw die alleg.lib zu linken, sonst wird das nichts mit dem Compilieren.
Wenn alles geklappt hat sollte der Bildschirm bei Programmstart einmal schwarz blinken und dann sollte sich das Programm beenden.

===== Anfang des Aufbaus einer kleinen Allegro-Wrapper Headersammlung =====
Da es gewisse Sachen gibt, die immer wieder vorkommen - wie der obrige Quellcode - habe ich angefangen eine Sammlung von Headern anzulegen, in denen Funktionen und Klassen rund um Allegro enthalten sind. Und das Ganze werden wir jetzt auch machen.

==== Ordnerstruktur ====

Ich habe im Ordner mit meinen eigenen Header einen Ordner AllegroW angelegt.
Dieser Ordner enthält die Datei Allegro.hpp, einen Ordner SRC und einen Ordner Header.

  * AllegroW  
    * Allegro.hpp
    * SRC
      * Source-Dateien
    * header
      * Header-Dateien

Erstellt am Besten eine ähnliche Ordnerstruktur.
Hier der Inhalt der Allegro.hpp:

<code cpp>
/*je nach Laune, and time, I used a tolle Mischung aus Englisch and German.
 *who takes Anstoß at this, der soll diese Klassen nicht benutzen. */

#ifndef ALLEGROHPP
#define ALLEGROHPP

typedef const char* coch;

#include <allegro.h>

#include "header/Functions.h"
//hier kommt später noch mehr dazu

#endif
</code>

Hier die nächste Datei:

==== AllegroW/header/Functions.h ====

Nun folgt der Header Functions.h (gehört in den Ordner header):

<code cpp>
#ifndef FUNC_H
#define FUNC_H

namespace allg{
    void initialisieren(int, int);
    BITMAP *createCircle(int Durchmesser, int ColorF, int ColorB);
    BITMAP *createRectangle(int w, int h, int Color);
}

const char* UppWord(const char* Word);

#endif
</code>

Hier steht zwar schon mehr drin, als wir im Moment brauchen, aber wenn ihr sie jetzt schon mal so anlegt, dann kann ich es später nicht vergessen. Hier gibt es auch keinen Quellcode, den ich erklären müsste, also lass ich es mal drin.

==== AllegroW/SRC/Functions.cpp ====

Anschließend noch im Ordner SRC die Datei Functions.cpp 
mit folgendem Inhalt anlegen:

<code cpp>
#include "../Allegro.hpp"

#include <sstream>
#include <ctype.h>

using namespace allg;

const char* UppWord(const char* Word);

//------------------------------------------------------------------------------
void allg::initialisieren (int W, int H){
    //Allegro einschalten
    if (allegro_init() != 0){
        exit(1);
    }

    //Grafik initialisieren
    set_color_depth(32);
    if (set_gfx_mode(GFX_AUTODETECT, W, H, 0, 0) != 0) {
        set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
        allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
        _sleep(5000);
   }

   /*Hier wird später noch mehr hinkommen*/
  

}
//--------------------------------------------------------------------
const char* UppWord(const char* Word){

    std::string Temp;
    Temp.clear();

    for(int i = 0;i<strlen(Word);i++){
        if(!isupper(Temp[i]) && Temp[i] != 32){
            Temp.push_back(toupper(Word[i]));
        }else{
            Temp.push_back(Word[i]);
        }
    }
    return Temp.c_str();
}
//------------------------------------------------------------------------------
BITMAP *allg::createCircle(int Durchmesser, int ColorF, int ColorB){
    BITMAP *retB = create_bitmap(Durchmesser, Durchmesser);
    clear_to_color(retB, ColorB);
    circlefill(retB, Durchmesser/2, Durchmesser/2, Durchmesser/2, ColorF);
    return retB;
}
//------------------------------------------------------------------------------
BITMAP *allg::createRectangle(int w, int h, int Color){
    BITMAP *retB = create_bitmap(w, h);
    clear_to_color(retB, makecol(255,0,255));
    rectfill(retB, 0, 0, w, h, Color);
    return retB;
}

</code>

Wir werden in Zukunft immer mehr Header- und Quelltext-Dateien in unserem AllegroW-Ordner sammeln, und ich werde auch darauf zurückgreifen.
In zukünftigen Codes gehe ich davon aus, dass ihr den Ordner AllegroW in einem Ordner liegen habt, der dem Includeverzeichnis des Compilers hinzugefügt wurde, sodass wir wie folgt drauf zugreifen können:
<code cpp>#include <AllegroW/Allegro.hpp></code>

Alles unter der Funktion initialisieren ignoriert ihr bitte, kopiert es mit, aber macht euch keine Gedanken über den Code, der wird erst später relevant.


Hier gehts zurück: [[Allegro:start|Index]] Und da gehts weiter:[[Allegro:bitmap|Das Bitmap-Object]]