Installation

cd ~
mkdir -p ~/bin ~/lib/python2.7

Bevor zusätzliche python Module installiert werden können, müssen erst noch zwei zusätzliche Verzeichnisse erstellt werden, falls diese nicht bereits existieren.

easy_install-2.7 virtualenv
virtualenv --no-site-packages env

Nun können wir das virtualenv Paket installieren und uns für Pyramid eine isolierte Umgebung erstellen. Der –no-site-packages Parameter ist zwar mittlerweile das Standardverhalten aber man weiß ja nie.

cd env
bin/easy_install pyramid

Als nächstes wechseln wir in unsere neue python Umgebung und installieren Pyramid selbst.

bin/easy_install flup

Zum Schluss wird noch flup installiert, da es später für das fcgi Skript gebraucht wird.

Pyramid Projekt erstellen

Es gibt mehrere Wege um ein Pyramid Projekt zu erstellen. Einer wäre es das ganze manuell von Hand zu schreiben. In den meisten Fällen ist es aber sinnvoller sich von Pyramid ein Template Projekt erstellen zu lassen. Wie das geht werde ich euch als nächstes zeigen.

cd ~/env
bin/pcreate -s starter MyProject

Innerhalb unserer selbst erstellten python Umgebung rufen wir den pcreate Befehl auf um ein Projekt namens MyProject mit dem “starter” Template zu erstellen.

cd MyProject
../bin/python setup.py develop
../bin/python setup.py test -q

Nun installieren wir unser Projekt im ‘development mode’. Dazu wechseln wir in das Projektverzeichnis und führen setup.py develop aus. Zum Schluss kann mit setup.py test -q noch ein unit test durchgeführt werden um zu prüfen ob alles seine Ordnung hat.
Sollte kein Fehler aufgetreten sein ist das Projekt jetzt bereit für die Außenwelt erreichbar gemacht zu werden.

Projekt erreichbar machen

Mittlerweile haben wir Pyramid erfolgreich installiert und ein Template Projekt erstellt. Aber leider ist es noch nicht über das Web erreichbar. Dafür schreiben wir als nächstes einen kleinen Wrapper der unsere python Anwendung startet.

cd ~/fcgi-bin
vim MyProject
 
##############################
#!/home/USERNAME/env/bin/python
import sys
 
from paste.deploy import loadapp
from flup.server.fcgi_fork import WSGIServer
 
myapp = '/home/USERNAME/env/MyProject'
 
sys.path.insert(0, myapp)
app = loadapp('config:' + myapp + '/production.ini')
 
if __name__ == '__main__':
        WSGIServer(app).run()
#############################
 
chmod 755 MyProject

Ich werde an dieser Stelle nicht im Detail erklären was das fcgi Skript eigentlich macht. Das kann uns aber auch egal sein, da es ja bloß unser Pyramid Projekt starten soll.
Zu beachtet ist aber, dass das Skript in ~/fcgi-bin liegt und optimalerweise den selben Namen wie euer Projekt hat damit es im Nachhinein leichter zu zuordnen ist.
Im Skript sollte USERNAME logischerweise mit dem eigenen Uberspace username ersetzt und die Pfade gegebenenfalls angepasst werden, solltet ihr andere benutzt haben als ich. Nachdem ihr das Skript erstellt habt bekommt es noch entsprechende Zugriffsrechte damit man es auch problemlos ausführen kann.
Damit ist euer Pyramid Projekt auch schon im Web unter http://USERNAME.SERVER.uberspace.de/fcgi-bin/MyProject.

Zum Schluss kann man das Projekt noch mit einer Suddomain verbinden, damit man nicht jedes mal fcgi-bin in der URL stehen hat.

mkdir /var/www/virtual/$USER/subdomain.domain.tld && cd $_
vim .htaccess
 
#############################
RewriteEngine on
RewriteRule ^(.*)$ /fcgi-bin/MyProject/$1 [QSA,L]
#############################

Mit diesen zwei einfachen Schritten werden alle requests auf subdomain.domain.tld auf unser fcgi Skript umgeleitet, welches dann wiederum unser Pyramid Projekt aufruft.

Schlusswort

Wenn alles glatt gelaufen ist solltet ihr nun Pyramid mit einem funktionierenden Template Projekt haben, dass dazu auch noch leicht aufzurufen ist.
Bei jeglichen Problemen könnt ihr euch gerne jederzeit in den Kommentaren oder per Twitter an mich wenden. Feedback ist wie immer gerne gesehen.
Ich hoffe dieses kleinen Tutorial konnte euch helfen. Viel Spaß mit Pyramid und bis zum nächsten mal.

Die Qt Project Datei – qgl1.pro

QT += opengl
TARGET = qgl1
TEMPLATE = app
SOURCES += main.cpp \
    glwidget.cpp
HEADERS  += \
    glwidget.h

Qt hat ein eigenes Modul für OpenGL spezifische features wie z.b. das QGLWidget welches wir als Ausgabefenster benutzen werden.
Mit der Zeile Qt += opengl teilen wir Qt mit, dass wir das Modul laden und benutzen wollen. Sonst gibt es an der Projekt Datei nichts besonderes zu beachten.

Der GLWidget Header – glwidget.h

#ifndef GLWIDGET_H
#define GLWIDGET_H
#include <QGLWidget>
 
class GLWidget : public QGLWidget
{
    Q_OBJECT
public:
    explicit GLWidget(QWidget *parent = 0);
protected:
    void initializeGL();
    void resizeGL(int width, int height);
    void paintGL();
};
#endif // GLWIDGET_H

Qt stellt mit QGLWidget ein sehr schönes Widget zu Verfügung, dass uns viel Arbeit bei der Initialisierung und Benutzung von OpenGL abnimmt.
Wir includen QGLWidget, erstellen eine eigene Klasse und vererben ihr QGLWidget.

Wie in der Qt QGLWidget Dokumentation zu sehen ist besitzt QGLWidget eine Reihe von virtueller Funktionen. Von diesen Funktionen interessieren uns im Moment nur drei, nämlich initializeGL, resizeGL und paintGL.

Der GLWidget Code – glwidget.cpp

#include "glwidget.h"
 
/* konstruktor */
GLWidget::GLWidget() {
    setWindowTitle("QGL1");
}

Der Konstruktor sollte selbst erklärend sein. Wir setzen nur den Fenster Titel und das wars auch schon.

/* initialisierung von OpenGL */
void GLWidget::initializeGL() {
    // schaltet smooth shading an
    glShadeModel(GL_SMOOTH);
    // stellt die Farbe zum clearen des bildschirms auf schwarz
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
    // stellt die beste perspektiven korrektion ein
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}

Bitte entschuldigt sollten die Kommentare etwas schwer verständlich sein. Normalerweise kommentiere ich ausschließlich in Englisch und es ist etwas ungewohnt sie in Deutsch zu schreiben.

Die Funktion initializeGL() wird immer vor dem ersten Aufruf von paintGL() oder resizeGL() und nach jeder GLContext Zuweisung aufgerufen. In ihr sollen alle Aufgaben zur Initialisierung von OpenGL ausgeführt werden. In unserem einfachen Beispiel müssen wir nur ein paar Einstellungen festlegen.

Smooth shading sorgt dafür das die Farben von Polygonen sauber ineinander überlaufen. Desweiteren hat es Effekte auf Lighting Effekte die wir im Moment außen vor lassen.
Die clear color wird dafür benutzt um am Anfang von jedem Frame die Zeichenfläche komplett zu übermalen. Sie dient uns also auch indirekt als Hintergrundfarbe.
Als letztes teilen wir OpenGL noch mit, dass wir die beste Perspektiven Korrektion benutzen möchten. Das benötigt zwar etwas mehr Rechenaufwand liefert aber ein deutlich besseres Ergebnis.

/* fenster größe ändern */
void GLWidget::resizeGL(int width, int height) {
    // aktuellen viewport resetten
    glViewport(0, 0, width, height);
 
    // projektions matrix auswählen
    glMatrixMode(GL_PROJECTION);
    // matrix resetten
    glLoadIdentity();
 
    // orthogonale ansicht einstellen
    glOrtho(0, width, height, 0, -1, 1);
 
    // modelview matrix auswählen
    glMatrixMode(GL_MODELVIEW);
    // matrix resetten
    glLoadIdentity();
}

resizeGL() wird nicht nur ausgeführt wenn sich die Größe des Widgets ändert, sondern auch einmal bei deren Erstellung. Dementsprechend kümmern wir uns hier um den Viewport, die Transformationsmatrizen usw.

Als erstes wählen wir unsere Projektionsmatrix aus und setzen diese mit glLoadIdentity() auf die Einheitsmatrix zurück. Die folgende glOrtho() Funktion berechnet dann für uns eine parallele Projektionsmatrix.
Mit der Parallelprojektion sorgen wir dafür, dass die Z Koordinate keinen Einfluss mehr auf die Größe hat, in der ein Objekt gezeichnet wird. Wir schalten OpenGL also in einen 2D Modus. Mit den Parametern der Funktion definieren wir die Dimensionen unseres View Volumes.

OpenGL hat kein striktes Koordinatensystem wie man sie aus anderen Grafik librarys kennt, denn es unterteilt die Zeichenfläche nicht in Pixel sondern in Einheiten die man selbst definieren kann.
Ich persöhnlich definiere es gerne aber trotzdem in der Pixelgröße des Ausgabefensters mit dem Ursprung in der oberen linken Ecke.
In folgenden Tutorials werde ich nach und nach tiefer in die Materie vordringen. Vorallem wenn wir in 3D zeichnen werden wird es noch etwas komplizierter. Im Moment soll es uns aber nicht weiter stören.
Zum Schluss resetten wir die Modelview Matrix und sind mit der Funktion fertig.

/* zeichnet die szene */
void GLWidget::paintGL() {
    // setzt den color und depth buffer zurück
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // resettet die modelview matrix
    glLoadIdentity();
 
    glBegin(GL_TRIANGLES);
        // oben
        glColor3f(1.0f, 0.0f, 0.0f);
        glVertex2d(width()/2, 0.0f);
        // unten links
        glColor3f(0.0f, 1.0f, 0.0f);
        glVertex2d(0, height());
        // unten rechts
        glColor3f(0.0f, 0.0f, 1.0f);
        glVertex2d(width(), height());
    glEnd();
}

Nun kommen wir endlich zum eigentlichen zeichnen unseres tollen Dreiecks. In jedem Frame rufen wir als erstes glClear() und glLoadIdentity() auf um die Buffer und Modelview Matrix zurück zu setzen.
glBegin(GL_TRIANGLES) teilt OpenGL mit, dass wir Dreiecke zeichnen möchten und glEnd() signalisiert am Ende logischerweise das wir fertig sind.
Ein Dreieck besteht wie der Name schon sagt aus drei Ecken also müssen wir innerhalb des glBegin/glEnd Blocks 3 Vertices definieren.

Ein Vertex (Plural: Vertices) ist ein Punkt im Raum und besteht aus zwei bis vier Koordinaten. Ein Weg um in OpenGL Vertices zu definieren ist die glVertex Funktion. Diese hat verschiedene Suffixe jenachdem wieviele Koordinaten von welchem Typ wir angeben wollen.
In unserem Fall benutzen wir glVertex2d(), weil wir ein Vertex mit 2 Koordinaten (x, y) des Typs Interger definieren möchten.
Um dem ganzen noch etwas Glanz zu verleihen verändern wir vor jedem Vertex die Zeichenfarbe um einen Verlauf zu bekommen.

Die main Methode und das Schlusswort

#include <QtGui/QApplication>
#include "glwidget.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    GLWidget window;
    window->show();
 
    return a.exec();
}

Die main Methode sollte wohl von jedem ohne zusätzliche Worte zu verstehen sein. Ich habe sowieso schon wieder viel zu viel geschrieben.
Hoffentlich kann euch dieses kleine Tutorial bei euren Anfängen mit OpenGL weiterhelfen.
In den nächsten Tutorials wird es dann etwas interesanter und wir werden Themen wie 3D, Transparenz, Translation, Texturen usw behandeln. Außerdem werde ich euch andere Zeichentechniken zeigen, die um einiges besser sind als den hier aus Einfachheit benutzten Intermediate Mode. Dann hoffentlich auch knackiger mit weniger Worten

Bitte korrigiert mich sollten sich Fehler eingeschlichen haben. Kommentare und Feedback sind immer erwünscht und bei Fragen könnt ihr mich auch gerne auf Twitter anschreiben. Anschließend verlinke ich euch noch den kompletten code als tar Archiv.

Bis zum nächsten mal

Download source code

Dabei ist mir vorallem ein großartiger Vortrag aufgefallen, nämlich “Geeks und Depressionen” von Stephan Urbach und Jens Ohlig. Dieses sehr wichtige Thema wird leider kaum erwähnt, denn man redet nicht gerne über solche unangenehmen Sachen und schweigt lieber darüber. Dabei grassiert es immer mehr in der Bevölkerung und das nicht nur bei uns Geeks.
Der immer stärker werdende Leistungsdruck und die hohe Erwartungshaltung in Beruf sowie auch im Privatleben zerren an den Nerven und können eine Person in ein tiefes Loch stürtzen aus dem man so leicht nicht wieder herauskommt kann. Dabei erkennt die Umwelt viel zu selten wenn ein Mitmensch mit solchen Problemen zu kämpfen hat und tragischerweise kommt es so immer wieder zu Selbstmorden von großartigen Personen. Aus gegebenen Anlass möchte ich folgend meine eigenen Gedanken zu diesem Thema offenlegen.

Es gibt viele Gründe wieso man unter Depressionen leiden kann, zum Teil sind diese der betroffenen Person nicht mals selbst bewusst. Es ist unglaublich wichtig, dass wir auf unsere Mitmenschen achten und Zeichen von Depressionen erkennen und ihnen unsere Hilfe anbieten.
Dabei sind Freunde wie Herr Urbach in seinem Vortrag schon sagte keine Therapeuten. Wir können anderen eine helfende Hand reichen und sie stützen aber nicht selbst therapieren.
Dafür ist keiner von uns ausgebildet und im schlechtesten Fall verschlimmern wir nur die Situation für die betreffende Person.
Wir können ihnen aber helfen wieder in einen geregelten Alltag zu kommen. Mal zusammen an die frische Luft gehen, sich einfach unterhaltet und etwas unternehmen.
Nur lasst sie nicht mit ihren Problemen ganz alleine daheim sitzen.

Nun habe ich darüber geredet wie man aus der Sicht des Außenstehenden anderen hilft. Was ist aber wenn ich selbst Depressionen habe? Wie kann ich mir selbst helfen damit zurecht zukommen?
Nun, das beste Mittel ist wohl sich zu überwinden und zu einem Fachmann zu gehen. Therapeuten sind immerhin dazu ausgebildet Menschen mit solchen Problemen zu helfen.
Ich habe selbst mit gewissen Problemen zu kämpfen, die ich hier nicht weiter erläutern werde, aber aus eigener Erfahrung kann ich sagen, dass Techniken zur Entspannung z.b. sehr helfen.

Den Kopf für einen Moment zur Ruhe zu bringen und durchzuatmen kann sehr gut tun. Ein Freund empfiehlt zu diesem Zweck z.b. Yoga Stunden zu nehmen. Auch einfache körperliche Betätigung wie Sport, radfahren oder spazieren gehen können helfen.
Ich persöhnlich mache Zazen, dass sind Meditationen mit denen man alle Gedanken im Kopf zum schweigen bringen kann um für einen Moment absolute Stille und Ruhe zu haben. Vorallem bei einer immer länger werdenen ToDo Liste ist das sehr erleichternd und entspannend. Und nein das ist kein pseudo-religiöser Hokuspokus sondern einfache Techniken um den Geist zur Ruhe kommen zu lassen die auch Atheisten, wie ich selbst einer bin, benutzen können.
Natürlich ist das nicht unbedingt für jeden etwas aber ich denke da kann jeder für sich selbst den besten Weg aussuchen.
Desweitern kann man sich Meilensteine bei den zu erledigenden Aufgaben setzen und sich bei deren Erfüllung selbst mit etwas belohnen und sei es ein Bierchen zum Feierabend oder mal wieder ins Kino zu gehen.

Was ich dem sehr guten Vortrag von Herr Urbach und Herr Ohlig zum Schluss noch hinzufügen möchte ist der Hinweis, dass Depressionen auch oft mit anderen Problemen und Krankheiten verbunden sind. Stempelt Depressionen nicht sofort als “nur” Depressionen ab sondern geht zu einem Therapeuten und lasst ihn entscheiden was mit euch nicht stimmt.
Es gibt viele psychische Probleme die mit Depressionen eingehen wie z.b. Borderline. Vondaher bitte ich euch wirklich zu einem Experten zu gehen und euch nicht selbst diagnostizieren.

Sobald der Vortrag von der sigint online ist werde ich ihn nochmal verlinken. Für den Moment habe ich aber genug zu diesem Thema geschrieben.
Bei Anregungen und oder Kritik könnt ihr wie immer gerne einen Kommentar hinterlassen.

Installation

cd ~
mkdir bnc
cd bnc

Als erstes erstellen wir einen Ordner für den bouncer.

wget http://znc.in/releases/znc-0.206.tar.gz
tar -xzvf znc*.*gz

Nun laden wir die ZNC sources als tarball herunter und entpacken das ganze. Für den Fall, dass ihr eine andere Version heruntergeladen habt gebe ich den Namen beim entpacken mit * an.

cd znc*
./configure --prefix=$HOME/bnc

Jetzt wechseln wir in das soeben entpackte Verzeichnis und rufen das configure script auf. Dabei muss aber darauf geachtet werden, mit dem prefix Parameter das Zielverzeichnis zu ändern. Der default Pfad ist nämlich /usr/local/ und dort haben wir keine Zugriffsrechte.

make
make install
rm -rf znc*

Nun muss das ganze nur noch installiert werden und znc ist auf eurem Uberspace unter dem Pfad $HOME/bnc zu finden. Da wir die sources nicht mehr benötigen können wir diese mit dem letzten Befehl entfernen. Bitte achtet aber darauf, dass nichts anderes außer die sources und das tarball archiv mit znc anfangen denn sonst löscht ihr diese Daten auch.

Konfiguration

cd ~/bnc/bin
./znc --makeconf

Als erstes erstellen wir  eine Konfigurationsdatei indem wir znc mit dem Parameter makeconf aufrufen. Daraufhin wird ein Assistent ausgeführt der das conf file  für uns erstellt. Dieser ist eigentlich recht simpel vondaher werde ich nicht großartig ins Detail gehen.
Den Port solltet ihr >1023 wählen und euch gut merken, denn über diesen port connected ihr dann mit username und passwort auf eurem bouncer. Von Haus aus sind diese Ports aber bei Uberspace blockiert.
Hier habt ihr zwei Möglichkeiten.
Ihr könnt den guten Jonas anschreiben und euch den Port freischalten lassen oder aber ihr erstellt einen Tunnel durch den ihr dann zu dem bouncer connecten könnt.

Schlusswort

Damit ist der ZNC bouncer auch schon aufgesetzt und betriebsbereit.
Für weitere Einstellungen könnt ihr im Wiki von ZNC unter http://wiki.znc.in/ZNC vorbeischauen, dort steht alles nötige.
Bitte schreibt mir solltet ihr Probleme mit der Installation oder einen Fehler entdeckt habt.

Ich hoffe dieses kleine tut war hilfreich für euch.
Bis zum nächsten mal

Nun gibt es verschiedene Arten in denen man stecken bleiben könnte. Zum Beispiel weil man Verständnis Schwierigkeiten hat und die Aufgabenstellung erst garnicht versteht. Es könnte aber auch an einer externen Library die nicht richtig funktioniert liegen, dass wir in unserem Projekt nicht weiterkommen. Es gibt unendlich viele Faktoren wieso man in seiner Arbeiten stecken bleiben könnte.

Wenn ich an einem programmier Projekt arbeite versuche ich immer modular zu entwickeln und das Projekt möglichst gut zu unterteilen. Modular zu arbeiten ist, wie jedem klar sein sollte, besser als irgendwie alles aufeinmal zu machen und hoffen, dass es am Ende zusammen passt.
Trotz meinem modularen Ansatz muss ich zu einem gewissen Grad natürlich an das gesamte System denken und wie die Module am Ende ineinander greifen werden.
Genau hier beginnt der Teufelskreis.

Halb unbewusst fangen meine Gedanken an von der eigentlichen Aufgabe abzuschweifen. So tauchen immer mehr Fragen auf: “Wie gestalte ich das Modul am besten? Gibt es ein passendes Design Pattern für diesen Zweck und wenn ja welches wäre am besten geeignet? Welcher Algorithmus ist besser um Problem xy zu lösen? In was für einer Datenstruktur speichere ich die Daten am besten? Und überhaupt, was wenn…..”
So überschlagen sich die Gedanken und man bleibt in einer der schlimmsten Arten stecken.

Man bleibt nämlich stecken, weil man Angst davor hat stecken zu bleiben.

All diese unbewussten Fragen führen dazu, dass die eigentlich klare Aufgabe immer größer und komplexer scheint. Anstatt loszulegen und Sachen im Zweifelsfall einfach auszuprobieren quält man sich mit Fragen “was wenn” und verliert die Motivation mit der Arbeit anzufangen. Bevor man sich versieht ist man auf youtube oder twitter und verschwendet seine Zeit.

Was kann man nun dagegen machen? Tja, das ist eine gute Frage.
Ich glaube es ist wichtig erst einmal den Grund zu erkennen wieso man überhaupt stecken geblieben ist. Wenn es daran liegt, dass man Angst hat während des programmierens irgendwann stecken zu bleiben, dann muss man sich “einfach” dazu zwingen trotzdem anzufangen.
Es muss einem klar sein, dass etwas auszuprobieren besser ist als sich den Kopf zu zerbrechen und doch zu keinem Ergebnis zu kommen.
Selbst wenn man zuerst einen falschen Ansatz nachgeht und ihn später wieder ändert. Dann ist man um Erfahrung reicher und auf dem richtigen Weg anstatt nur zu grübeln und am Ende überhaupt nichts zu machen.

Versteht mich nicht falsch, es ist gut wenn man seine Programme plant und durchdenkt und ich will auch niemanden davon abraten. Aber wenn es dazu führt, dass man nicht mehr weiterkommt, dann ist es besser die Gedanken beiseite zu schieben und einfach anzufangen zu arbeiten.

In diesem Sinne wünsche ich euch viel Erfolg bei euren Projekten und bis zum nächsten mal.

Wie ihr sehen könnt ist das nicht unbedingt wenig und es zeigt auch nicht alle Elemente, aber gibt dafür einen ganz guten Überblick. Einzelne Komponenten wie das Debug/Logging System, cross platform highres Timer, Memory Allocators usw sind bereits implementiert aber es ist noch viel Arbeit zu erledigen.
Demnächst werde ich näher auf einzelne Module eingehen und auch den Code zeigen. Also schaut doch ab und zu mal vorbei.

Eine weitere Interessante Eigenschaft stellen die p und g Instruktionen dar, mit denen man den Code während der runtime verändern kann. Vondaher kann man sehr intressante Algorithmen schreiben die am Ende sogut wie garnicht mehr nachvollziehbar sind.

Chris Pressey hat Befunge erfunden um eine möglichst schwer zu compilierende Programmiersprache zu definieren. Soweit ich weiß, gibt es auch keinen richtigen Befunge Compiler der ordentlich funktioniert.
Zum Schluss noch ein kleines Beispiel Programm, Hello World Extended von Wikipedia.

91+70pv

v p173<        v  < 

>"!dlroW olleH">,:|

     v:-1g17      <

^ p17_$70g,v

^_ #&@#p173<

Das Bild am Rand sollte verdeutlichen wie wenig 25km in Wirklichkeit sind im Vergleich zu einer stabilen Umlaufbahn unseres Planetens. Dennoch ist es schon garnicht mal so wenig. Hoch genug, dass man die Erdkrümmung gut erkennen kann und sich schon fast wie im Weltall fühlt
Natürlich wollen wir nicht auf gut Glück etwas hochfliegen lassen und hoffen, dass alles heil wieder zurück auf den Boden kommt, sondern führen vorher wissenschaftliche Tests durch. Denn es gibt in solchen Höhen mehr Probleme als man zuerst denkt. Die Temperaturen betragen ca -65c° und in so einer Kälte funktionieren viele normale Batterien z.b. erst garnicht mehr und die gesamte Stromversorgung würde zusammenbrechen.
Mit der Nutzlast wollen wir 2 HD Kameras, 5 LD Kameras, mehreren Temperatur-, Feuchtigkeits- und Luftdruck-/Höhenmesser sowie einen Strahlungsmesser auf die Reise schicken. Per Funk werden die Messdaten mit den aktuellen GPS Koordinaten zurück zum Boden gesandt.

Innerhalb der nächsten Wochen werden die ersten Prototypen erstellt und getestet. Ich werde während der Arbeiten immer wieder Updates schreiben und euch auf dem laufenden halten. Falls jemand von euch mal selbst einen Wetterballon starten lassen möchte und etwas Starthilfe braucht kann er oder sie sich gerne bei mir melden. Denn es gibt vorher viel zu Regeln, wie z.b. eine Starterlaubnis der Deutschen Flugsicherung und Versicherungen etc pp.

Wie üblich ist Feedback immer gerne gesehen

Den Anfang machen Living World und Moon Engine. Ich beschäftige mich in meiner Freizeit, wie so viele andere auch, gerne ab und zu mit Computerspielen. Als Programmierer habe ich schnell den Wunsch verspürt irgendwann einmal selbst ein Spiel zu designen, planen und schließlich zu realisieren.
Man muss sich natürlich klar machen, dass ein Spiel ein unglaublich großes Softwareprojekt ist und es sehr viel Arbeit bedeutet. Ein Programmierer sollte seine Grenzen kennen und sich von unrealistischen Zielen trennen, vorallem wenn er es alleine oder in einem kleinen Team umsetzen will.

Living World ist der Projektname eines 2D Action RPG nach Vorbildern wie Secret of Mana oder Bastion. Der 2D Grafikstil wurde gewählt, weil ich finde, dass es einen gewissen Charm hat und weil es um einiges weniger Arbeit bedeutet als alles in 3D umzusetzen. Man kann erstaunliche Resultate erziehen, wenn man eine 2D Sicht mit modernen Techniken verbindet. Ich werde an dieser Stelle noch keine Details zum eigentlichen Gameplay, der Story oder den Features verraten. Diese Informationen werde ich zusammen mit den Entwicklungsfortschritt nach und nach vorstellen. Last mir euch aber sagen, dass es teilweise sehr erfrischende und dynamische Fähigkeiten besitzt, die man so ehr selten sieht. Natürlich behauptet so etwas jeder von seinem Produkt, aber ihr werdet es am Ende ja selbst sehen können

Das zweite Projekte, dass ich euch vorstellen möchte ist eng mit Living World verbunden. Es handelt sich um eine sehr kleine und simple 2D Game Engine, die ich Moon Engine genannt habe.
Schon in den Anfängen meiner Arbeit an Living World habe ich festgestellt, dass ich erst einmal sehr grundlegende Systeme schaffen muss, auf denen ich dann letztendlich aufbauen kann. Da ist mir die Idee gekommen, dass ich auch direkt eine eigene simple Game Engine schreiben kann.
Aber wieso sollte man sich die Mühe machen und eine eigene Engine schreiben wenn es doch so viele viel bessere und optimiertere Engines gibt die man frei benutzen kann.
Naja, ganz einfach weil ich es kann. Vorallem geht es mir darum zu lernen wie solche Engines aufgebaut sind und wie sie funktionieren. Das kann man am besten indem man selbst eine erstellt. Ich finde, dass sich die Erfahrungen und das Wissen was man sich dabei aneignet den Aufwand auf jeden fall rechtfertigen.

Beide Projekte sind sehr ambitioniert und groß. Ich mache mir keinerlei Illusionen, dass die Resultate großartig seien werden und mir eventuell sogar Geld in die Tasche spülen. Darum geht es mir auch garnicht. Ich möchte einfach nur etwas neues lernen und meine Erfahrungen mit anderen teilen.
Ich hoffe, dass manche von euch an diesen Themen Interesse haben und mehr darüber lesen möchten. Sollte dies so sein könnt ihr natürlich gerne Kommentare hinterlassen.
Ich freue mich immer über jegliches Feedback.

Puh, jetzt wurde es doch etwas mehr Text als beabsichtigt und es soll für den Moment auch reichen.
Bis zum nächsten mal.