Das Script lädt die Datei mit cURL über die offzielle Website hoch. Nicht wirklich eine saubere Lösung, funktioniert aber perfekt. Naja, fast: Über die Website sind nur Uploads bis 150MB möglich, meine Backup-Zips sind aber inzwischen schon 188MB groß (ich blogge zu viel ). Daher habe ich mir ein kleines Script gebastelt, das die Dateien durchgeht, und alle die größer als 100MB sind, mit Hilfe von split in Teile á 100MB schneidet. Dabei wird dann einfach ein fortlaufender Buchstabe an den Dateinamen angehängt. Dazu habe ich das Upload Script noch so modifiziert, das es Dateien, die größer als 100MB sind, gar nicht erst hoch lädt (da sie eh nicht verarbeitet werden).

Als drittes im Bunde habe ich dann noch ein kleines Script das einen Dump der Datenbank erstellt, und zu guter Letzt noch ein Script, das alle die kleinen anderen Scripte der Reihe nach aufruft (und dabei noch ein VERBOSE Option zum testen durchreicht).

Mit diesem System habe ich jetzt meine Backups hoffentlich im Griff Bash-Scripting ist nicht wirklich mein Lieblingsthema… Aber ich hatte jetzt auch keine Lust das in C++ zu machen

Soviel zur Theorie, hier sind die ganzen Skripte:

Der Dump der Datenbank:

/usr/bin/mysqldump --all-databases --user=backup --password=verratichnicht > /var/backup/sqldump/backup_full_`date "+%y_%m_%d"`.sql

Das Zerteilen der Dateien in kleine Stücke:

#!/bin/bash

function split_dir
{
for i in *; do
if [ -f "$i" ]; then
FILESIZE=$(stat -c%s "$i")
if [ $FILESIZE -gt "104857600" ]; then
if [ $VERBOSE -eq 1 ]; then
echo "$1 is too big, splitting"
fi
split -a 1 -b 100M $i `basename $i`_
fi
fi

if [ -d "$i" ]; then
local OLD_PWD=$(pwd)
cd "$i"
split_dir "$1/$i"
cd "$OLD_PWD"
fi
done
}

cd $1
split_dir $1

Mein modifizierter Dropbox-Uploader: (Nur als Diff, sonst ist das ewig viel Text, das Original gibst hier)

26,27c26,27
< LOGIN_EMAIL="ich@ich.de"
< LOGIN_PASSWD="supergeheim"
---
> LOGIN_EMAIL=""
> LOGIN_PASSWD=""
90c90
<
---
>
101,107c101,102
<     FILESIZE=$(stat -c%s "$UPLOAD_FILE")
<
<     if [ $FILESIZE -gt 104857800 ]; then #file to big for upload (slighly more than 100M
<          print  "$UPLOAD_FILE is too big, ignoring."
<     else
<         curl $CURL_PARAMETERS -i -b $COOKIE_FILE -o $RESPONSE_FILE -F "plain=yes" -F "dest=$DEST_FOLDER" -F "t=$TOKEN" -F "file=@$UPLOAD_FILE"  "$UPLOAD_URL"
<         grep "HTTP/1.1 302 FOUND" "$RESPONSE_FILE" > /dev/null
---
>     curl $CURL_PARAMETERS -i -b $COOKIE_FILE -o $RESPONSE_FILE -F "plain=yes" -F "dest=$DEST_FOLDER" -F "t=$TOKEN" -F "file=@$UPLOAD_FILE"  "$UPLOAD_URL"
>     grep "HTTP/1.1 302 FOUND" "$RESPONSE_FILE" > /dev/null
109,116c104,108
<         if [ $? -ne 0 ]; then
<             print " Failed!\n"
<             if [ $END_ON_UPLOAD_ERROR -eq 1 ]; then
<                 remove_temp_files
<                 exit 1
<             fi
<         else
<             print " OK\n"
---
>     if [ $? -ne 0 ]; then
>         print " Failed!\n"
>         if [ $END_ON_UPLOAD_ERROR -eq 1 ]; then
>             remove_temp_files
>             exit 1
117a110,111
>     else
>         print " OK\n"

Und jetzt noch das eigentliche Skript, das alle aufruft, und dabei die -v Option durchreicht:

#!/bin/bash

#Helper scripts that calls all the backupscripts.
#-dumps all MySQL DBs
#-split big zip files in /backup
#-uploads all to dropbox

VERBOSE=0

#if the first argument is -v, the verbose mode for this scritp, and all scripts called is enable
if [ "$1" == "-v" ]; then
VERBOSE=1
fi

#create the MySQL dump
if [ $VERBOSE -eq 1 ]; then
echo "Doing DB Dump..."
fi
./backup_db.sh

#split big files
if [ $VERBOSE -eq 1 ]; then
echo "Splitting files..."
fi
env VERBOSE=$VERBOSE ./split_files.sh /var/backup

#upload all
if [ $VERBOSE -eq 1 ]; then
echo "Starting upload..."
./dropbox_uploader.sh -f /var/backup -d /ServerBackup -v
else
./dropbox_uploader.sh -f /var/backup -d /ServerBackup
fi

#done
if [ $VERBOSE -eq 1 ]; then
echo "Done!"
fi

Die Krönung wäre jetzt noch ein kleines Programm, das die Dateien auf meinem Rechner erkennt, wieder zusammensetzt, und in die Dropbox schiebt. Aber das kann ich immer noch machen, wenn ich das Backup mal brauche

Mal sehen, wie sich mein Sammelsurium von Skripten so macht!

Lösung: Einfach alle so verschieben, dass der Koordinatenursprung in der Instance da ist, wo man ihn haben will…

Kurz ein paar Worte zum Hintergrund: Mit .NET 4.0 wurde die sog. Dynamic Language Runtime (DLR) eingeführt. Die dient zum einen dazu, es Entwicklern einfacher zu machen, neue Sprache auf .NET Basis zu entwickeln (wie IronPython/IronRuby), hat aber auch ein paar tolle andere Features zu bieten. Eines davon ist das neue Schlüsselwort “dynamic”. Es funktioniert ähnlich wie “var” kann also jeden Typ annehmen. Wenn man darin aber ein Objekt speichert, das von System.Dynamic.DynamicObject abgeleitet ist, kann man bestimmen was passiert, wenn etwas “nicht erlaubtes” passiert, also wenn z.B. eine Methode aufgerufen wird, die es gar nicht gibt. Solche Aufrufe landen dann bei der Methode TryInvokeMember, und die kann dann entscheiden, was passieren soll.

Dieses Konzept habe ich jetzt genutzt, um einen Wrapper für das LuaInterface zu schreiben. Das Lua Interface ist eine Library für .NET, die es erlaubt, Lua in C# zu benutzen. Dabei kümmert sie sich auch darum, .NET Objekte in Lua abzubilden und vieles mehr. Diese Library ist wirklich unglaublich, man denkt wirklich, Lua hätte was mit Objekten am Hut.

Meine Idee war es jetzt, über das LuaInterface eine neue Hülle zu stecken, die es zusammen mit der DLR ermöglicht, Lua noch einfacher in C# (und anderen .NET Sprachen zu benutzen). Hier ein kleines Beispiel:

// Start a new Lua interpreter
dynamic lua = new DynamicLua.DynamicLua(); //Namespace and class name are the same!
// Run Lua chunks
lua("num = 2"); //no DoString()!
lua("str = ’a string’");
// Read global variables ’num’ and ’str’
double num = lua.num; //No explicit casting, no index operator!
string str = lua.str;
// Write to global variable ’str’
lua.str = "another string"; //No index operator
//Increase a global value
lua.num += 10; //A LOT cleaner

Wie man sehen kann wird eine neue Instanz des Interpreters erzeugt, wenn man ihn aufruft wie eine Funktion wird der Lua Code ausgeführt. Variablen aus Lua sind einfach als Eigenschaften des Objektes vorhanden. Es ist kein Problem, .NET Klasse an Lua zu schicken, eine einfache Zuweisung reicht. Noch ein paar der Features:

• Einfacher Zugriff auf Lua-Variablen
• Aufruf von Lua-Funktionen aus C#
• C#-Funktionen können in Lua Variablen gespeichert werden
• Lua-Table können in C# Variablen gespeichert werden
• Lua Metatables können in C# benutzt werden
• Open-Source (Apache Lizenz 2.0)
• Unit-Tests

Ich denke, mit DynamicLua ist es wirklich einfach Lua in C# einzubinden, weil vieles genau so funktioniert, wie man es erwarten würde. Das war zumindest mein Design-Ziel.

Genug der lobenden Worte, alles weitere ist auf der Codeplex-Seite zu finden: DynamicLua bei Codeplex. Momentan ist dort die Beta der Version 1.0 zu finden.

Also habe ich mich mal etwas im Netz umgesehen, und bin auf der Seite von Ulrich Müller gelandet, der sich die Mühe gemacht hat, allen möglichen Sprachen Bibliotheken zu schreiben. So gibt es auch ein in C#. Leider ist die Benutzung grade mit Windows 7 etwas kompliziert, daher will ich hier mal kurz erklären, wie es funktioniert. An dieser Stelle noch mal einen Dank an Ulrich Müller, der mit per Mail weiter geholfen hat.

Als erstes brauchen wir die USB-Treiber für das Interface, sonst ist gar keine Kommunikation möglich. Alternativ ist auch der Betrieb über COM möglich, aber so richtig ist das ja auch nichts… Die Treiber werden zusammen mit ROBO Pro installiert, wer die CD aber nicht findet, kann auch auf der Fischertechnik-Seite eine ZIP-Datei mit verschiedenen Hilfemitteln herunterladen, im Ordner /Driver sind dann die Treiber zu finden. Den Download gibt es hier: Fischertechnik Download-Seite (Treibersoftware KeLib).

Jetzt brauchen wir noch eine DLL, die die eigentliche Kommunikation übernimmt, und einen Wrapper in der passenden Sprache. Beides gibt auf der Seite von Ulrich Müller. Weil die Downloads etwas schwer zu finden sind, erlaube ich mir mal Deep-Links:

• umFish.dll
• FischFace.dll

Die beiden oben angegebenen Dateien brauchen wir für die Kommunikation. Die Downloads enthalten noch etwas mehr, hauptsächlich Dokumentation. Davon ist auch auf der oben verlinkten Seite einiges zu finden.

Die umFish.dll ist die eigentliche Bibliothek zum steuern des Interfaces, die FishFace.dll nur der Wrapper für C#.

Wir fügen also beide Dateien einem neuen C# Projekt hinzu, und fügen einen Verweis auf die FishFace.dll hinzu. Mit folgendem Code stellen wir eine Verbindung zum Interface her:

using System;
using System.Collections.Generic;
using System.Text;
using FishFace40;

namespace ftTest
{
class Program
{
static void Main(string[] args)
{
FishFace ft = new FishFace();
ft.OpenInterface(IFTypen.ftROBO_first_USB, 0);
}
}
}

Mit den Parametern von OpenInterface() kann man die Schnittstelle auswählen, und über die Seriennummer auch mehr als ein Interface ansteuern. Am Ende des Programms sollte dann natürlich auch noch eine CloseInterface() stehen. Die restliche Steuerung ist ziemlich selbst erklärend, darum gehe ich da nicht weiter drauf ein.

Ich persönlich habe jetzt auch ein anderes Interface umgeschwenkt, dass ich von der Schule gestellt bekomme, weil ich die Verbindung zum Fischertechnik-Interface erst nicht hinbekommen habe (falsche Version der umFish.dll). Ist aber trotzdem praktisch, wenn man mal wieder was in der Richtung machen will…

Wenn ihr noch Fragen habt, einfach in die Kommentare damit.

Naja, etwas kleines neues gibt es doch: Ein Freund fragte mich, ob ich noch diese Website kenne, wo man beliebigen Text eingeben kann, und er dann zum Linux Quelltext würde. Scheinbar hat er das was verwechselt, ich kann mich jedenfalls nicht daran erinnern eine solche Seite gekannt zu haben

Jedenfalls hat er mich auf die Idee gebracht sowas mal zu programmieren, und das ist dabei herausgekommen:

Geht einfach auf diese Website, und zeigt allen, dass ihr den Linux Kernel aus dem Kopf schreiben könnt:

Update: Neue Version: Be a Pro Coder/Hacker

Be a Linux Coder/Hacker

Der Quelltext den ihr da schreibt stammt aus dem Linux Kernel, aus /kernel/irq/irqdesc.c. Ihr könnt die Seite gerne speichern und den Text ändern, aber er muss vorher für JavaScript escaped werden, und alle Zeilenumbrüche müssen natürlich durch ein <br> ersetzt werden.

Vorschläge für noch “schlimmere” Quelldateien im Kernel werden gerne angenommen, aber das Ding ist sauber geschrieben, ich musste schon richtig nach einer “komplizierten” Datei suchen. Ach: Der Kernel ist nicht auf kernel.org sondern auf GitHub zu finden!

UPDATE: Jetzt könnt ihr euch auch an dem FAT-Treiber aus GRUB oder der 99 Bottles of Beer Version in Brainfuck versuchen Und der Bug der in den Kommentaren angesprochen wurde, ist auch weg…

Die Lösung war dann das Wikitionary: Das hat, wie jedes auf MediaWiki basierendes Wiki eine API. Dort kann man zwar auch eine zufällige Seite (=Wort) abrufen, aber eben nicht aus einer bestimmten Kategorie. Ich wollte nun aber nur deutsche Substantive. Durch etwas rumsurfen bin dann auch folgende Lösung gekommen:

private static string GetRandomNoun()
{
StringBuilder sb = new StringBuilder(3);
for (int i = 0; i < 3; i++)
{
sb.Append(alphabet[random.Next(26)]);
}

WebClient wc = new WebClient();
wc.Proxy = null;
wc.Headers.Add(HttpRequestHeader.UserAgent, "info@niklas-rother.de");
string response = wc.DownloadString(String.Format("http://de.wiktionary.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Substantiv_%28Deutsch%29&cmsort=sortkey&cmstartsortkey={0}&cmlimit=1&format=xml", sb.ToString()));

XmlDocument doc = new XmlDocument();
doc.LoadXml(response);

return doc["api"]["query"]["categorymembers"]["cm"].Attributes["title"].InnerText;
}

Das wichtigste ist dabei DownloadString(), hier wird eine Abfrage an die Wikitionary API gestellt. Dabei wird eine Liste der Kategoriemember abgefragt, doch mit einem kleinen Trick: cmstartsortkey wird auf ein zufälliges Buchstaben-Trippel gesetzt, und dadurch wird nur der Eintrag zurückgegeben, der diesen drei Buchstaben lexikographisch folgt. Man kann auch noch mehr Buchstaben benutzten, aber mit drei Buchstaben sollte man schon viele Wörter erwischen.

Kurze Rechnung: Die Kategorie Substantiv (Deutsch) hat 34.390 Seiten. Aus 3 mal 26 Buchstaben kann man 26³ = 17.576 Kombinationen machen. Das sind 51%. Man erwischt also theoretisch die Hälfte der Wörter, das sollte reichen. (Ja, ich mag Mathe )

Ein paar kleine Fallstricke gibt es noch: Die Wikitionary API will unbedingt einen UserAgent haben, also muss man einen setzen, wie oben gesehen. Dort sollte am besten eine Adresse für Beschwerden drin sein, falls sich ein Programm mal selbständig macht…

Und auch .NET hat noch eine kleine Eigenheit: Wenn man eine neue Instanz von WebClient das erste Mal benutzt, wird versucht einen Proxy zu finden. Das kann bis zu 30sec dauern. Will man nicht warten, setzt man die Eigenschaft Proxy einfach auf null, und verscherzt es sich mit Leuten, die einen Proxy nutzen…

Und zum Abschluss gibt es noch ein schönes Zufälliges Wort: Presslufthammer!

Wer Munin zum überwachen seine(r/s) Server(s) benutzt (wie ich) kennt wahrscheinlich auch den Graph, der die Speicherauslastung anzeigt. Der sieht ungefähr so aus:

Aber ganz ehrlich: Ich steige da nicht durch… Zum einen ist der Graph blöd skaliert (ich habe nur 200MB RAM, aber er geht bis 25GB), und man kann auch nicht wirklich erkennen, ob man nun noch Speicher hat oder nicht.

Also dachte ich mir, bauen ich doch mein altes Skript etwas um, und integriere es in Munin. Das ist gar nicht schwer, denn es gibt natürlich eine passende Anleitung.

Also das Skript ein bisschen umgeschrieben, und fertig ist das Ding. Um es in Munin zu integrieren muss es natürlich ausführbar gemacht werden (chmod a+x file) und unter /etc/munin/plugins ein Link auf die Datei angelegt werden. Danach noch munin-node neustarten, und fertig ist das eigene Plugin.

Überwacht werden der vorhandene und benutzte RAM und Swap. Die Daten werden aus der Ausgabe von free gewonnen. Ein Bild kann ich leider noch nicht zeigen, ich habe das ja selber erst seit 30min laufen… Aber ich hoffe doch auf ein besseres Bild als das da oben. Hier ist also der komplette Code:

#!/bin/sh

#Munin Plugin to monitor the ouput of free
#Written by Niklas Rother 2011

case $1 in
config)
cat <<'EOM'
graph_title Memory ussage
graph_vlabel Vytes
RAM_total.label Total RAM
RAM_used.label Used RAM
Swap_total.label Total Swap
Swap_used.label Used Swap
graph_args --base 1024 -l 0
graph_scale yes
graph_category other
graph_info This graph shows some values of the output of "free". The buffer/cache adjusted values are used.
RAM_total.info The total ammount of build in RAM (free total colum)
RAM_used.info The ammount of RAM currently used by processes (excluding buffers and caches)
Swap_total.info The total ammount of availible available Swap
Swap_used.info The ammount of Swap currently used by processes
EOM
exit 0;;
esac

echo -n "RAM_total.value "
free|grep Mem:|awk '{ print $2 }'

echo -n "RAM_used.value "
free|grep cache:|awk '{ print $3 }'

echo -n "Swap_total.value "
free|grep Swap:|awk '{ print $2 }'

echo -n "Swap_used.value "
free|grep Swap:|awk '{ print $3 }'

Zum einen ist da YaME: Yet another Minecraft Engine. Hier ein kleines Video:

Ich wollte mal etwas in 3D mit XNA machen, und habe aus Spaß dieses Projekt angefangen. Momentan gibt es schon endlose Landschaften (zumindest bis der Speicher voll ist ), und die Framerate ist noch akzeptabel. Ich werde wohl zumindest noch bessere Grafiken und etwas Physik einbauen, zusammen mit einem besseren Renderer (Octrees und Occlusion Culling wäre super)

Dann bin ich grade dabei das LuaInterface um die Fähigkeiten der DLR zu erweitern. Microsoft hat mit .NET 4 eine bessere Interoperabilität mit Scriptsprachen eingebaut: Mit dem Schlüsselwort “dynamic” kann man Objekte definieren, die z.B deren genaues “Aussehen” erst zu Laufzeit festgelegt wird. Außerdem ist es damit möglich viele expliziete Konvertierungen wegzulassen. Das passt natürlich wunderbar zu Lua, und dem LuaInterface, mit dem man schon jetzt sehr elegant aus .NET auf Lua zugreifen kann. Kleines Code-Beispiel gefällig?

dynamic lua = new DynamicLua();
lua("function test() return 'hello from lua' end");
lua.test2 = new Action(() => return "hello from c#");
Console.WriteLine(lua.test());
Console.WriteLine(lua.test2());

Aus lua.DoString(“bla”) wird ein einfaches lua(“bla”), Variablen lassen sich einfach als Eigenschaften von lua verwenden, und die Zuweisung sowie der Aufruf von C#-Methoden ist einfach möglich. Obwohl jeder Aufruf einer Lua Method immer ein object-Array zurückgibt, ist eine einfache Verwendung in WriteLine() möglich, es wird automatisch in einen String umgewandelt.

Der größte Teil der “Magie” wird dabei vom LuaInterface übernommen, ich habe dem ganzen nur ein modernes Gewand in Form eines “dynamischen” Objektes übergestülpt. Momentan arbeite ich noch daran ein paar Fehler auszumerzen. Ich habe das LuaInterface überings auch mit dem .Net Framework 4 kompatibel gemacht. Je nachdem wie hartnäckig die Fehler noch sind, dürfte das Projekt bald fertig sein.

Als drittes überlege ich grade, so etwas wie key-mon für Windows zu schreiben. Die Linux Version ist sicher für Screencast ziemlich praktisch… Mit dem nKF und dem KeyboardButton Selektor sollte sich da was machen lassen… Ich bin echt schockiert, das es sowas für Windows nicht gibt?!

Ich habe mir irgendwie zu viel vorgenommen Naja, bald sind ja Ferien, da habe ich dann genug Zeit mich darum mal zu kümmern.

Wie muss man die Texturkoordinaten eines Würfels setzen, damit auf allen Seiten die gleiche Textur zu sehen ist?

Mit nur acht Vertices geht es nicht (für jede Ecke einer), aber mit 12 geht es:

Man verzeihe meine Paint-Künste… Die hinteren Vertices müssen doppelt vorhanden sein, die obere und untere Seite wird dann mit diesen Vertices generiert. Die Farben geben die Texturkoordinaten an, die Zahlen an den Ecken sind die Nummern der Vertices. Weil ich ja so nett bin, gibt es die passenden Indices jetzt auch noch dazu:

<span id="more-1363"></span>

int[] indices = new int[] {
 0, 1, 2, 2, 3, 0, //vorne
 1 ,8 ,9 ,9 ,2 ,1, //oben
 2 ,6 ,7 ,7 ,3 ,2, //rechts
 10 ,0 ,3 ,3 ,11 ,10, //unten
 4 ,5 ,1 ,1 ,0 ,4, //links
 7 ,6 ,5 ,5 ,4 ,7  //hinten
 };

Das ganze ist effizienter, als den Würfel mit 24 oder gar 36 Vertices zu definieren, grade wenn man viele davon braucht

Bald gibts auch einen Post darüber, was ich mit vielen Würfeln will…

Und genau da liegt das Problem: Snoopy beachtet nur die beiden Weiterleitungsheader “Location” und “URI”. Location ist der quasi-Standard, was anderes habe ich noch nicht gesehen.

Leider musste Netscape mal wieder sein eigenes Süppchen kochen und hat den “Refresh”-Header erfunden. Dieser Header ermöglicht noch ein paar mehr Sachen, wie Verzögerungen, wird aber fast nicht mehr eingesetzt.

Leider verwenden ihn einige Webanwendungen noch, wenn sie auf einem IIS laufen. Dieser hat nämlich in der Version 5.1 ein Problem mit dem Loacation-Header… So eine Anwendung ist der Bugtracker Mantis. Und mein Plugin WP-Mantis benutzt eben Snoopy um die Changelogs und Roadmaps abzurufen. Jetzt hat mich vor einiger Zeit ein Benutzer des IIS angeschrieben, und nach einiger Fehlersuche haben wir dann den Fehler in Snoopy gefunden.

Leider hat sich WordPress geweigert, meinen Fix zu akzeptierten, (Naja, Snoopy ist dort auch veraltet) darum will ich ihn hier noch mal publizieren.

Die Sachen ist ziemlich einfach: Für WordPress muss die wp-includes/class-snoopy.php geändert werden:

Zeile 867 muss so geändert werden:

if(preg_match("/^(Location:|URI:|Refresh:)/i",$currentHeader))

Und Zeile 870 muss wie folgt lauten:

preg_match("/^(Location:|URI:|Refresh:[ ]+[0-9]+;[ ]*url=)[ ]*(.*)/i",chop($currentHeader),$matches);

Wer also WP Mantis auf einem IIS System einsetzt sollte diese Änderung berücksichtigen. So 100%ig sicher bin ich mir bei dem RegEx nicht, er sollte aber funktionieren
Bild © by Gianfranco Goria on Flickr

Das ganze wurde aus Eigenbedarf geschrieben, ich wollte das Widget einsetzen, aber ich schreiben zu wenige Artikel um es zu füllen

Es ist ganz unten auf der Seite zu sehen. Wenn noch jemand einen Vorschlag hat, immer her damit… Wäre auch gut, wenn sich jemand den HTML Code anschauen könnte, ich muss die Breite auf 25% setzen, sonst sieht es bescheuert aus, das Original funktioniert aber auch ohne solche Hacks. Leider finde ich den Fehler nicht…

Wer es benutzen will findet es im WordPress Plugin Directory als WP Month Calendar.

BTW: Shotty, du hast meinen Mauszeiger nicht richtig aufgenommen, ich hovere doch grade über einem Link…

Im Grunde hat der Packer drei Probleme zu lösen:

1. Das Tileset muss verschnitten werden
2. Doppelte Tiles müssen aussortiert werden
3. Das Tileset muss effektiv wieder zusammen gesetzt werden

Dazu sollte das Programm natürlich eine gewisse Geschwindigkeit an den Tag legen. Das verschneiden kann man relativ einfach mit Bitmap.Clone erledigen, doch das ist sehr langsam, und dazu nimmt die Geschwindigkeit auch noch mit zunehmender Größe der Bitmap ab. (Große Bitmap = langsamer Code). Es musste also eine Alternative her. Durch einen Tipp in einem Forum bin ich dann auf Bitmap.LockBits gestoßen, eine Methode die direkt (unsafe) auf die Bitmap zugreift und dadurch sehr schnell ist. Von dieser Methode bekommt man ein BitmapData Objekt, mit dem man über einen Pointer auf die Daten im Arbeitsspeicher zugreifen kann.

Diese Daten verwendet dann die Methode GetHash, die aus den Bitmapdaten einen Hash generiert, mit dem doppelte Tiles aussortiert werden können.

static string GetHash(BitmapData data)
 {
 using (Bitmap tmp = new Bitmap(data.Width, data.Height, data.Stride, data.PixelFormat, data.Scan0))
 {
 using (MemoryStream ms = new MemoryStream())
 {
 tmp.Save(ms, ImageFormat.Bmp);
 rawData = ms.ToArray();
 }
 }

 for (int i = 54; i < rawData.Length; i++) //the first 54 byte are the bitmap header
 {
 rawData[i] &= 252; //1111 1100 letzden bits auf null setzen
 }

 return BitConverter.ToString(md5.ComputeHash(rawData, 54, rawData.Length - 54));
 }

Dazu wird zunächst direkt aus den Daten (auf die der Pointer Scan0 zeigt) eine neue Bitmap erstellt (sehr praktisch, dieser Konstruktor ), die dann in einem Memory-Stream geschrieben wird. Zwar kann man auch direkt auf die Daten in Scan0 zugreifen, aber diese sind scheinbar mit Nullen aufgefüllt. Das Array, auf das Scan0 zeigt ist zumindest viel zu groß und enthält extrem viele Nullen (neben den richtigen Daten).

Eine Bitmap hat leider eine 54 Byte großen Header, der im nächsten Schritt übersprungen werden muss. Normalerweise existiert dafür das Format ImageFormat.MemoryBitmap, das sich aber zum speichern scheinbar nicht benutzen lässt (Null-Exception). Laut Wikipedia kann der Header auch größer sein, was bei mir aber nie der Fall war.

In der Schleife wird dann schließlich das gesamte Array durchlaufen und bei allen Einträgen die beiden unteren Bits auf 0 gesetzt. Dadurch werden die Zahlen “gerundet” und minimaler Abweichungen, die durch Kompression werden nicht mehr als unterschiedliche Tiles gezählt. Danach wird der md5-Hash der Daten als String zurück gegeben.

Danach werden die Bitmapdaten wieder freigegeben. Man beachte, dass die erstellte Bitmap wieder zerstört wird. Stattdessen wird nur das Rectangle, das den Ausschnitt darstellt gespeichert. Das nicht nicht unbedingt das schnellste, aber es ist so relativ einfach, und die Geschwindigkeit ist auch so noch sehr hoch.

Das letzte Problem, das noch gelöst werden muss, ist das effektive packen der Tiles. Nick Gravelyn hat ein wunderbares Programm zu diesem Zweck geschrieben, das ich auch erst verwendet habe. Dazu musste ich aber alle Tiles in Dateien schreiben, was relativ langsam ist, dazu ist das Programm mehr für unterschiedlich große Bilder gedacht. Nach etwas nachdenken bin ich dann auf eine Lösung gekommen, mit der man ausrechnen kann, wie viele Bilder man in eine Reihe packen muss, damit die Seitenlängen des fertigen Bildes minimal ist: Perfekt wäre √(TileCount), doch die Tiles sollen ja nicht abgeschnitten werden . Also wird die Zahl aufgerundet. Dadurch muss die andere Seite etwas kürzer werden. Das fertige Bild hat dann folgende Seitenlängen:

int packedXCount = (int)Math.Ceiling(Math.Sqrt(IDToRectangle.Count)); //IDToRectangle.Count = Anzahl der unterschiedlichen Tiles
 int packedYCount = (int)Math.Ceiling((double)(IDToRectangle.Count) / packedXCount);

Auch wenn mir kein Beweis einfällt würde ich vermuten, das diese Lösung perfekt ist, also immer das optimale Ergebnis liefert.

Jetzt müssen die Tiles nur noch kopiert werden (vom alten zum neuen Tileset):

foreach (KeyValuePair<int, Rectangle> kvp in IDToRectangle)
 {
 //crop rectangle and copy it to the output
 BitmapData tileSetData = TileSetImage.LockBits(kvp.Value, ImageLockMode.ReadOnly, TileSetImage.PixelFormat);
 using (currTile = new Bitmap(tileSetData.Width, tileSetData.Height, tileSetData.Stride, tileSetData.PixelFormat, tileSetData.Scan0))
 {
 packedGraphics.DrawImage(currTile, 32 * packedRowCount, 32 * packedColCount);
 }
 TileSetImage.UnlockBits(tileSetData);

 //PackedRow/Col zählen
 packedRowCount++;
 if (packedRowCount >= packedXCount)
 {
 packedRowCount = 0;
 packedColCount++;
 }

 }

Hier wird wieder eine Bitmap erstellt, in dem das Tileset gelocked wird, danach wird die Bitmap auf das neue Tileset gemalt. Dabei werden intern wohl nur die Daten kopiert, sodass das ziemlich schnell funktioniert.

Das waren alle interessanten Stellen, der Rest ist mehr oder weniger Standard. Mir hat das ganze gezeigt, das man auch mit C# Bilder schnell bearbeiten kann, obwohl alles managed ist, also z.B. immer gelocked werden muss. Wem das ganze immer noch zu langsam ist, der kann auch unsafe Code verwenden, bei dem er dann mit den Daten machen kann, was er will.

Es gibt einen Scripteditor der auf ScintillaNet basiert, und den Inhalt auch an einen externen Editor senden kann. Dazu gibt es eine ComboBox für die Hintergrundmusik und ein DataGridView, das an ein Dictionary gebunden ist, wodurch man eigene Schlüssel-Wert-Paare festlegen kann.

Das ganze kann auch in eine Datei geschrieben werden und wird auch korrekt wieder ausgelesen.

Um die Karte in das Spiel zu bringen, kann man sie als xml-Datei exportieren. Leider ist der Renderer des Spiels noch etwas instabil, so dass man die Karte nicht direkt laden kann, da sie kleiner als der Bildschirm ist…

Als nächstes muss ich wohl mal einen ContentImporter für die xmap-Dateien schreiben, die der Editor ausspuckt. Da fände ich es noch super, wenn man aus dem Spiel direkt die Ansicht an den Editor schicken kann, und von dort die bearbeitete Version zurück in die Engine senden kann. Mal sehen, wie man das machen kann. Und auch sonst fehlen dem Editor leider noch ein paar Funktionen, die die Engine schon unterstützt wie NPCs und Tile Events…

Damit jetzt keiner denkt, ich wollte nur mit meinem Editor angeben oder müsste mal wieder einen Post schreiben obwohl es eigentlich nichts wichtiges gibt, (Was natürlich in keinster Weise stimmt ) gibt es jetzt auch noch einen Tipp:

Mein Editor basiert auf dem Unterbau von EvilNando, wer also auf der Suche nach einem sehr guten, erweiterbaren Editor auf C#/XNA Basis ist, wird dort fündig werden. Leider verwendet der Editor noch XNA 3.1, doch mit etwas Arbeit kann man ihn auf XNA 4 portieren. Wenn daran Interesse besteht kann ich auch darüber mal einen Post schreiben

Ich wünsche jedenfalls allen Lesern schon mal ein entspanntes Weihnachtsfest und gebe noch einen Ratschlag meines Lehrers zu Silvester auf den Weg: “Erst knallen, dann saufen!”

Die Klasse Color befindet sich jetzt nicht mehr unter XNA.Framework.Graphics, sonder nur noch unter XNA.Framework. Das für u.U. zu Problemen mit den usings, da es ja auch Windows.Forms.Color gibt. Hier ist der Trick, das man bei using auch einen alternative Namen angeben kann:

using XNA = Microsoft.XNA.Framework

Damit kann man jetzt z.B. mit XNA.Color auf die richtige Klasse zugreifen.

Das alte GraphicsDeviceSample funktioniert nicht mehr. Viele werden ihre WinForms Integration auf diesem Sample aus dem AppHub aufbauen, doch durch die Änderungen muss auch hier einiges geändert werden. Glücklicherweise hat Microsoft das schon gemacht, es reicht das Sample nochmal runterzuladen und die jeweiligen Dateien zu ersetzen.

Texure2D.FromFile heißt jetzt Texture2D.FromStream. Das war auch praktisch schon die gesamte Änderung… Ist nur eine Änderung des Namens, die Methode hat vorher auch schon Streams akzeptiert… Jetzt werden aber keine Dateinamen mehr angenommen, diese muss man in ein new FileStream() einbetten.

Texture2D.FromStream skaliert Texturen, die über 2048px groß sind. Dieses Problem hat mich ein paar Stunden gekostet: Ohne Änderung (s.u.) ist das GraphicsDevice auf das Reach-Profil eingestellt, was ja (wegen dem Windows-Phone) keine Texture zulässt, die größer als 2048px sind (in Höhe oder Breite). Leider werden größere Texturen, wenn man sie über OpenStream lädt nicht einfach mit einem Fehler abgewiesen sondern skaliert. Das führt dann natürlich zu sehr eigenartigen Effekten, wenn man weiterhin mit Pixelkoordinaten darauf zugreift. Mit Shadern gibt es keine Probleme, bei denen gehen die Koordinaten ja immer von 0-1. Eine direkte Lösung gibt es nicht, aber man kann das Profil ändern, wie ich jetzt beschreibe:

Das GraphicsProfil lässt sich nicht auf HiDef ändern. Bei normalen XNA Games kann man das GraphicsProfil ja in den Eigenschaften ändern, mit der WinForms-Integration fehlt diese Möglichkeit. Die Lösung findet sich in den App Hub Foren: In der Datei “GraphicsDeviceService” findet man folgenden Code (Z. 65):

graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter,
GraphicsProfile.Reach,
parameters);

Dort kann man das Profil wechseln.

Das neue Premultiplied-Alpha führt zu Darstellungsproblemen. Diese Probleme habe noch nicht ganz behoben, aber es sollte da keine große Probleme geben, da ich ja auch schon mal in meinem anderem Post beschrieben hatte, was sich geändert hat. Diese Änderung führt momentan bei mir nur zu ein paar weißen “Schatten”, was schon aber eigentlich ganz gut aus sieht

Auch hier muss ich wieder sagen: Gute Arbeit, XNA Team! Gute Änderungen eingebaut, aber trotzdem die API nicht elementar geändert. Nur der ärgerliche Effekt mit den Texturen ist meiner Meinung nach blöd gelöst.

Leider hat Mantis das ganze nicht eingebaut, so dass ich selber aktiv werden musste. Natürlich hat auch Mantis einen Bugtracker, und dort hat auch schon jemand einen Featurewunsch geäußert. Jemand anderes hat dann festgestellt, das Mantis doch schon Captchas unterstützt: Wenn man einen neues Account erstellt muss man Buchstaben erraten.

Genug der Vorrede: Wie baut man nun Captchas für Kommentare und Bugreports ein?

Kurze Antwort: Man wendet den Patch an, den ich zu dem Featurewunsch gepostet habe.

Lange Antwort: Es müssen 4 Dateien geändert werden: In zwei muss die Eingabemaske eingefügt werden, in die anderen zwei die Validierungslogik. Wie fangen mit der Datei “bug_report.php” an. (Alle Dateien finden sich im direkt im Mantis-Ordner) Hier wird nach Zeile 80 der folgende Code eingefügt:

// begin stone captcha check for anon user
if (current_user_is_anonymous())
{
$f_captcha = gpc_get_string( 'captcha', '' );
$f_public_key = gpc_get_int( 'public_key', '' );
$f_captcha = strtolower( trim( $f_captcha ) );
$t_key = strtolower( substr( md5( config_get( 'password_confirm_hash_magic_string' ) . $f_public_key ), 1, 5) );

if ( $t_key != $f_captcha ) {
trigger_error( ERROR_SIGNUP_NOT_MATCHING_CAPTCHA, ERROR );
}
}
// end of stone captcha check for anon user

Noch mal zur Kontrolle: Der Code muss an die Stelle des Kommentars (nur falls sich die Datei in einer neuen Version mal ändert…)

if ( access_has_project_level( config_get( 'roadmap_update_threshold' ), $t_bug_data->project_id ) ) {
$t_bug_data->target_version = gpc_get_string( 'target_version', '' );
}

//Hier kommt der Code hin

# if a profile was selected then let's use that information
if ( 0 != $t_bug_data->profile_id ) {
if ( profile_is_global( $t_bug_data->profile_id ) ) {

Weiter geht es mit der Datei “bugnote_add.php”. Hier kommt der gleich Code in die Zeile 40:

$f_time_tracking    = gpc_get_string( 'time_tracking', '0:00' );
$f_bugnote_text    = trim( gpc_get_string( 'bugnote_text', '' ) );

//Und auch hier kommt der Code hin

$t_bug = bug_get( $f_bug_id, true );
if( $t_bug->project_id != helper_get_current_project() ) {

Jetzt fehlt nur noch folgender Code, der das Eingabefeld ausgibt:

<?php //begin stone's captcha for anon login
    if (current_user_is_anonymous())
    {
    ?>
    <tr class="row-1">
    <td class="category">
        <span class="required"> * </span><?php echo lang_get( 'signup_captcha_request' ) ?>:
    </td>
    <td>
        <?php print_captcha_input( 'captcha', '' )
		$t_key = mt_rand( 0,99999 ); ?>
        <img src="make_captcha_img.php?public_key=<?php echo $t_key ?>">
        <input type="hidden" name="public_key" value="<?php echo $t_key ?>">
    </td>
	</tr>
    <?php
    }
    //end of stone's captcha for anon login?>

Der kommt in der Datei “bug_report_page.php” in die Zeile 515:

		<label><input <?php echo helper_get_tab_index() ?> type="checkbox" id="report_stay" name="report_stay" <?php check_checked( $f_report_stay ) ?> /> <?php echo lang_get( 'check_report_more_bugs' ) ?></label>
		</td>
	</tr>

//Auch hier kommt Code hin

	<tr>
		<td class="left">
			<span class="required"> * <?php echo lang_get( 'required' ) ?></span>

Und zu guter Letzt kommt das ganze auch noch mal in der “bugnote_add_inc.php” in die Zeile 74:

</tr>

<?php } ?>

//... (ich muss nichts mehr schreiben, oder?)

<?php if ( config_get('time_tracking_enabled') ) { ?>
<?php if ( access_has_bug_level( config_get( 'time_tracking_edit_threshold' ), $f_bug_id ) ) { ?>

Wichtig: Unbedingt hinter <?php } ?> einfügen!

Jetzt sollten die anonymen Benutzer erst das Captcha lösen müssen, bevor sie Bugs melden oder Kommentare abgeben können. Seit dieser Änderung habe ich keinen Spam mehr. Wer möchte, das diese Patch in die nächste Mantisversion kommt kann sich gerne im Bugtracker dafür aussprechen (oder das Feature sponsern)

MonoDevelop ist ansich ein tolle Software, die sogar VisualStudio 2008 kompatible Solution-Dateien schreibt. Leider wird unter Linux normalerweise das GTK# Toolkit verwendet, was sowas wie WinForms ist. Das funktioniert aber nur, wenn unter Windows die passende DLL vorhanden ist. Ich hatte mir aber vorgenommen, ein Programm zu schreiben, das unter Linux und Windows läuft, und dass ohne neu kompilieren oder zusätzliche Binaries.

Also musste ich WinForms verwenden, was in Mono auch relativ implementiert ist. Nur leider fehlt MonoDevelop der Designer dafür, sodass ich alles per Hand schreiben muss. Mit einem Designer würde man z.B. die Textboxen einfach ausrichten, ohne muss man das mit einem TableLayoutPanel machen. Und bis man das so konfiguriert hat, wie man sich das vorstellt wünscht man sich den Designer mehr als einmal zurück, glaubt mir. (Ich habe überings nicht bis jetzt daran gearbeitet, ich habe nur vergessen, darüber zu bloggen. Aber etwas mehr als die 20min hat es schon gedauert…)

Wenn man dann aber alles konfiguriert hat, hat man ein tolles Münzbrett, dass ohne jede Änderung auch auf Windows startet. Leider hat man da aber immer noch ein Konsole im Hintergrund…

Jetzt noch zwei Screenshots zum Vergleich zwischen Windows und Ubuntu:

Wenn man bei der Einstellung der FormBorderStyle nicht aufpasst hat man dieses tolle Ergebnis: Windows 98 Style!

Ergebnis: Man kann auch unter Linux Windows/portable Programme schreiben, aber wenn man mit WinForms arbeiten will empfehle ich ganz klar ein Visual Studio. Trotzdem finde ich es beeindruckend, das das Programm “einfach so” ohne neukompilieren auch auf Windows (und Mac OS?) läuft!

Wer selber testen will: E-Münzbrett.Net zum Download

1. XNA gibt es jetzt auch auf Deutsch! Das betrifft auch die komplette Dokumentation, also auch die IntelliSense Tipps. Eine super Sachen, finde ich, nicht weil ich Probleme mit der englischen Version hatte, sondern, weil es immer gestört hat, wenn im deutschen VisualStudio an und an englische Tooltipps erschienen
2. Es gibt von Microsoft ein “Performance Utility“. Das ist eine Overlaykomponente, mit der die Update und Draw Zeit angezeigt wird, eine FPS Anzeige, ein Overlay, dass einfach beliebige Werte anzeigt, und eine Ingame-Console.

Besonders freut mich die Console (wenn sie gut ist ), denn nachdem meine “alte” Console, nicht mehr für XNA 4.0 geupdatet wurde, musste ich mir was neues suchen. Für gewöhnlich sind die Sachen von Microsoft ja ziemlich gut (weil sie sie selber brauchen ), evtl. bleibt mir da noch Arbeit erspart. (Know when to be lazy)

Der Test kommt, wenn ich wieder Windows gestartet habe.

Alte XACT Dateien können nicht gelesen werden. Das Problem lässt sich sehr einfach beheben: Mit dem neuen Game Studio kommt auch ein neues XACT (auch Version 3.0, aber vom Februar 2010). Die alte Datei damit öffnen, Hinweis abnicken und wieder speichern, Problem behoben.

DisplayMode.RefreshRate fehlt. Eines der Probleme, die ich nicht wirklich beheben konnte. Um das Ruckeln von Animationen zu beheben hatte ich die FPS Rate an die Wiederhohlrate des Monitors angepasst. Da die entsprechende Eigenschaft jetzt einfach fehlt, kann ich das so einfach nicht mehr machen.

DLLs, die mit XNA 3.1 kompiliert werde produzieren Probleme. In The Kingdom od Darkness hatte ich eine Libary eingebunden, die die Konsole beinhaltet. Die ist natürlich noch für XNA 3.1 kompiliert, deswegen schlugen alle Zugriffe darauf mit dem Hinweis GameTime kann nicht in GameTime konvertiert werden fehl. Das ist natürlich Blödsinn. Ich habe die Konsole erst mal entfernt, werde sie aber wohl durch etwas anderes ersetzen. (Dazu später mehr)

Aus Effect.Begin/End wird Apply. Eine relativ einfache Änderung: statt für jeden Effect und Pass Begin und End aufzurufen wird nur ein mal für jeden Pass Apply aufgerufen. Technische Details bei Shawn.

Kein Rendertarget.GetTexture mehr. Das war wohl die einfachste Sachen: Ein RenderTarget ist eine Texture2D. Es kann also direkt in Draw verwendet werden.

Kein CompileEffectFromSource mehr. Das ist mein Hauptproblem. Weil es auf der XBox nicht möglich war Shader zu Laufzeit zu kompilieren wurde dieses Feature auch in der Windows Version gestrichen. Es ist zwar generell möglich, aber nur sehr umständlich und nicht auf Clients (Rechnern, die nur das Redistributable installiert haben). Details auch wieder bei Shawn. Damit muss ich mein tolles System, das Post-Processing Shader je nach Bedarf generiert wieder über Bord werfen

Es gibt keine Color Konstruktor mehr, der die Transparenz ändert. Es wird also aus jedem new Color(Color, byte) eine Color * byte. Das ganze dem Fakt geschuldet, das XNA jetzt vormultipliziertes Alpha benutzt. Ich musste zum Glück nicht viel ändern, sonst wäre ich zu Suchen&Ersetzen übergegangen.

Serialisierte Daten können nicht mehr gelesen werden. Etwas ärgerlich: Alle Klassen, die mit 3.1 serialisiert wurden, können mit 4.0 nicht mehr gelesen werden. Vermutlich gibt es da eine Möglichkeit das Laden zu erzwingen, ich habe einfach eine neue Klasse serialisiert. Wer seine Spielstände so speichert sollte aber aufpassen, das die nach dem Upgrade noch gelesen werden können!

Die Standardauflösung wurde geändert. Wenn man keine Auflösung angibt wird jetzt 800×480 statt 800×600 verwendet. Das entspricht einem Windows Phone im Querformat. Mit zwei Zeilen im Konstruktor war auch dieses Problem gelöst.

Die Assembly im gemischten Modus wurde während Version v2.0.50727 der Laufzeit erstellt und kann nicht während der 4.0-Laufzeit ohne zusätzliche Konfigurationsinformationen geladen werden. Da musste ich dann doch zu Google greifen Dieser Fehler besagt aber einfach nur, das .NET 4.0 (das jetzt automatisch verwendet wird) keine Assemblies mehr lesen kann, die für .NET 2.0 kompiliert wurden. In meinem Fall betraf das den LUA Wrapper LUA.NET. Wenn man folgenden Zeilen zu seiner app.config hinzufügt wird dieser Schutz aber umgangen:

<configuration>
  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0"/>
  </startup>
</configuration>

So, das waren alle Probleme, die ich im Bezug auf XNA 4.0 hatte. Relativ wenig, wenn man bedenkt, dass sie doch viel geändert haben.

Wenn meine Tilemap nicht so groß wäre (was noch geändert wird) könnte ich The Kingdom of Darkness sogar auf dem Reach Profil laufen lassen, das dann ohne Probleme auch auf dem Windows Phone laufen sollte. Wenn ich die Textur verkleinert habe, werde ich das bestimmt mal probieren

Die Lösung war eine Kombination aus der WP 3.0 Menü Funktion und einem kleinen PHP Hack. Zuerst ein Mal zu der Menü Funktion: Diese Funktion ist mit WordPress 3.0 verfügbar und ermöglicht es, unter Design/Menüs eigene Menüs zu erstellen. (Wenn das Theme das unterstützt) Nur was macht man damit? Zum einem kann das Menü einer Position im Theme zuweisen. Das ist praktisch, wenn man die automatische Menüanordnung nicht mag. Doch mit einem kleinem Eingriff wird das ganz noch mächtiger!

Alles was man machen muss, ist diese Zeilen in die funktions.php des Theme zu kopieren:

<?php
//Filter the arguments for the wp_nav_menu_function to include a custom menu on pages.
function nr_2010_wp_nav_menu_args($args = '')
{
	if(is_page()) //custom menus only on sites
	{
		global $post;
		$page_slug = sanitize_title($post->post_title);

		if(is_nav_menu('page-' . $page_slug)) //if a menu with the name page-{page url form} exists, use it.
		{
			$args['menu'] = 'page-' . $page_slug;
		}
	}
	return $args;
}
add_filter( 'wp_nav_menu_args', 'nr_2010_wp_nav_menu_args' );
?>

Kleine Erklärung: Es wird ein Filter auf die Parameter der wp_nav_menu gesetzt. In diesem Filter kann man die Parameter der Funktion ändern, bevor sie ausgeführt wird. (Alles Teil des genialen Plugin Systems von WordPress) Wenn grade eine Seite (is_page) angefragt wird, wird in der Variable post_slug die URL Form des Titels gespeichert und wenn auch ein Menu existiert (das wie oben beschrieben erstellt wurde), das den Name page-{post_slug} hat, wird dieses statt dem normalem Menü angezeigt.

Viel Text für eine einfache Erklärung: Ich kann einfach ein Menü mit einem passenden Namen erstellen, und es wird anstelle des normalen Menüs angezeigt! Super einfach

Verbesserungsideen: Den Namen des Menüs aus einem Custom Filed des Posts leses…