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.

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!

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…

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!”

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

Wie auch schon bei Version 0.9.3.1 habe ich auf der Downloadseite keinen neuen Eintrag erstellt, sondern einfach die Zipdatei ausgetauscht. Wer SimpleScreenshot schon hat, muss einfach nur auf das AutoUpdate warten, das bei nächsten Start aufgerufen wird.

Zur Download Seite…

Diesmal ist es nicht direkt ein Tipp, sondern mehr ein Hinweis:

Bei Bitmap.Clone(Rectangle, PixelFormat) ist eine OutOfMemoryException nicht, was man denkt!

Diese Tatsache wird zwar auch in der Dokumentation erwähnt, aber es hat mich jetzt schon zweimal fast zur Verzweiflung getrieben. Bitmap.Clone() verursacht eine OutOfMemoryException, wenn das Rectangle außerhalb der Bitmap liegt. Dann ist das Rectangle zwar auch “außerhalb des Speichers”, aber trotzdem ist das sehr unglücklich gewählt. Zudem zeigt das VisualStudio dann auch noch “Nicht genügend Abeitsspeicher” an. Das ist natürlich schlichtweg falsch!

Also nicht verzweifeln, sondern das Rectangle noch mal überprüfen

P.S.: Frohe Ostern

So geht es los, wenn man SimpleScreenshot startet. Also so wie bis jetzt. Höchstens der Text wird noch angepasst.

Die erste Neuerung: ein sog. Flyout! Das erscheint, wenn man ein Mal auf das Trayicon klickt. (In etwa so wie bei den Netzwerkeinstellungen) Dort kann man die aktuelle Kategorie sehen und ändern, den Pfad der letzten Datei sehen (und kopieren oder den beinhaltenden Ordner öffnen) und die URL des letzten Uploads sehen. Auch die kann man kopieren, im Browser öffnen (da hab ich das falsche Icon erwischt) und neu hochladen. Nützlich, wenn der Upload nicht geklappt hat, oder man ein Bild auf zwei Hostern haben will.

Wenn man nun auf “Ändern…” klickt, öffnet sich dieses Fenster. Oben wählt man die Kategorie aus (eine Kategorie ist praktisch ein Unterordner, in dem man seine Screenshots organisiert) die man dann löschen oder umbenennen kann. Bei löschen können die Screenshots auch automatisch in eine andere Kategorie verschoben werden. Natürlich kann man auch neue Kategorien erstellen.

Für eine Standardkategorie möchte man ja evtl. keinen Unterordner, auch das ist möglich. Evtl. wird man auch noch das Namensschema mit den Kategorien ändern.

Die Einstellungen, wie gewohnt. Einzige Änderung: Der Zurücksetzen-Button, mit man die Standardeinstellungen wieder aufrufen kann.

Hier hat sich einfach mal gar nichts geändert. Ich fand diese Seite eigentlich ziemlich gelungen.

Hier überschlagen sich die Änderungen dann aber wieder: Die ausgewählte Taste steht direkt auf dem Button zum Ändern des selben. Das gleiche Prinzip wende ich dann auch bei den anderen Tasten an, nur wird man hier nur Shift, Strg und Alt auswählen können. Dahinter wird noch die oben ausgewählte Taste angezeigt, so werde die Kombinationen klarer.

Auch auf der letzten Seite habe ich nicht viel geändert, nur das man den Hinweis auf mehr Hoster jetzt auch anklicken kann.

Jetzt das spannendste: Das Hauptfenster. Einige wollte das arme Fenster ja schon ganz entfernen, weil sie ihm keinen Nutzen abgewinnen konnten… Da hatten sie auch Recht, bis jetzt ist der Nutzen auch begrenzt. Das ändert sich jetzt aber:

Alle Buttons, bis auf die Einstellungen, fliegen raus, sind überflüssig. Die Vorschaugröße kann man jetzt oben einstellen, zudem kann man dort nach Aufnahmedatum filtern. Daneben ist ein Suchfeld für die Dateinamen.

Das vergrößerte Bild soll andeuten, das die Bilder jetzt größer werden, wenn man mit dem Mauszeiger “drüberhovert”. Jetzt muss ich nur noch das komische Blau erklären: Momentan werden die ausgewählten Screenshots noch durch ein blauen Quadrat dargestellt. Das entspricht aber nicht dem Verhalten des Windows Explorers. Dort wird das ganze durch so einen Farbverlauf dargestellt, wie ich etwas stümperhaft angedeutet habe.

Auch sonst wird SimpleScreenshot sich etwas mehr Windows 7 nähern, in dem es z.B. Task Dialogs statt einfacher Messageboxen nutzt. Momentan bin ich am überlegen, ob ich Windows XP noch weiter unterstütze. Da bin ich auf die Benutzer angewiesen: Braucht ihr XP Unterstützung, oder benutzt ihr eh schon Vista oder 7? XP bedeutet für mich auf jeden Fall mehr Arbeit für mich

Wo wir schon bei der “Community” sind: Ich werde alle Kommentare, die sich auf das Design beziehen zu diesem Artikel verschieben. In den Kommentaren wurde ja schon verschiedene Ideen gepostet, was man mit dem Design alles so machen kann. Ich hab versucht, alles in diesem Entwurf zusammen zusammenfließen zu lassen.

Wenn trotzdem noch jemand eine gute Idee hat, was das Design betrifft: Immer her damit. Auch sonst wird es natürlich noch weitere Änderungen geben, aber ich muss ja noch nicht alles verraten (Windowskontextmenü ist schon geplant )

Viel Text, aber nur mit der Absicht meine Ideen der harten Kritik zu stellen! Also macht meine Ideen fertig

EDIT: Man kann Kommentare gar nicht verschieben Naja, bleibt eben alles an seinem Platz…

Changelog:

• Updatesuche berücksichtigt jetzt keine Beta-Versionen mehr.
• Kleine Änderungen an dem Fehlerabfangcode, er meldet jetzt Fehler immer in Englisch, um auch Fehler mit den Sprachdatei melden zu können.
• Wenn ein Neustart benötigt wird, wird dieser jetzt automatisch durchgeführt.
• Neuere Version vom Tastenauswahl Fenster.
• Übersetzung minimal angepasst
• Beenden und Verstecken Button entfernt. Das Fenster wird durch minimieren Schließen versteckt, das Beenden ist über das Kontextmenü des Trayicons erreichbar.
• Fehler behoben, den auftrat, wenn man im Kontextmenü auf “Einstellungen” klicke, während das Einstellungsfenster geöffnet war. Mal wieder werden jetzt alle Einstellungen im Programmverzeichnis gespeichert.

Download:

Zur Download Seite…

Diese Version scheint aber einiges an Fehler zu beinhalten, also darum rate ich zum Download einer neueren Version.

Hier der Changelog:

• Update suche jetzt bei jedem Start (statt nur 1x täglich)
• Sinnvollere Standardwerte in den Einstellungen vergeben
• Rechtschreibfehler korrigiert
• Das Passwort für den Hoster wird jetzt verschlüsselt gespeichert (nur für kommende Versionen, noch ist diese Funktion nicht benutzbar)
• Wenn das Programm nicht über beim Windowsstart mitgestartet wurde, erscheint jetzt ein Ballontip mit dem Hinweis, das SimpleScreenshot im Tray läuft.
• Kleinere Umstrukturierung des Codes.
• %an% funktioniert jetzt.
• Eine fehlende Übersetzung hinzugefügt.
• Screenshots können jetzt mit einem Druck auf die Entf-Taste gelöscht werden.
• Der Kamerasound wird jetzt auch abgespielt, wenn SimpleScreenshot über die Autostart Verknüpfung gestartet wird.
• Über die Autostart Verknüpfung wird SimpleScreenshot minimiert gestartet. Dadurch wird das Aufblitzen eines Fenster verhindert.
• Neues Tastenauswahl Fenster (Vielen Dank an Nico für diese Komponente)

Also wieder einiges an Änderungen. Auf zwei Sachen muss ich noch näher eingehen:

Durch einige Änderungen an der Autostartverknüpfung (z.B. der /autostart Parameter) muss diese neu erstellt werden. Dazu bitte ein Mal den Autostart ein den Einstellungen deaktivieren und speichern, dann kann alles wieder aktiviert werden.

Zudem geht %an% jetzt zwar, aber wenn kein Fenster aktiv ist ( = der Desktop aktiv ist) dann wird “explorer” eingefügt, da dann natürlich die Windows Shell aktiv ist… Wenn jemand eine sichere Methode weiss, das Handle der Shell zu bekommen, immer her damit. Oder stört euch dieses “Feature” gar nicht?

Ansonsten alles wie gehabt, diese Version gibt es auch wieder als AutoUpdate. Für alle neu Einsteiger:

Zur Download Seite…

Noch eine Notiz an mich selber: Morgen Übermorgen mal ein paar Screenshots von SimpleScreenshot einfügen

Genauer gesagt:

• Schließen Button in der Platzhalterliste funktioniert
• Bei der Auswahl eines Speicherorts, der nicht nur Bilddateien enthält (z.B. Desktop) tritt kein Fehler mehr auf.
• Bilder können aus dem Fenster gezogen werden (Drag&Drop)
• Einstellungen werden (mal wieder) nur im Anwendungsverzeichnis gespeichert.
• Der Image Editor (Auswahlrahmen) kann jetzt deaktiviert werden.
• Speichern als JPEG funktioniert jetzt
• Speichern in Word funktioniert einwandfrei.
• Die Meldung, das ein Neustart von SimpleScreenshot benötigt wird, wird wird angezeigt, wenn er auch wirklich nötig ist.
• Meldung bei Absturz sollte gehen.

Einen Fehler konnte ich nicht beheben: Die Pause Taste ist theoretisch als Auslöser benutzbar, aber nicht im Zusammenhang mit der STRG Taste, weil die Kombination (ein Relikt wie einiges an Windows) Batchprogramme unterbricht. Darum wird diese Kombination leider nicht an SimpleScreenshot gemeldet, und ich kann nicht darauf reagieren…. So lange man die Taste aber nicht zusammen mit der STRG Taste benutzt, geht aber alles wunderbar.

Eine Sache, die geplant war, ist auch nicht drin: Der neue Button Selector von Nico. Denn der braucht wohl noch etwas um meine Meldungen zu verarbeiten Sobald ich von ihm eine neue Version bekomme, gibt es wieder ein Update.

Wo wir grade bei Updates sind: Die neue Version sollte ab sofort (bzw, ab morgen, da nur ein Mal am Tag nach Updates gesucht wird) über das Autoupdate bereit stehen. Ich würde also alle Benutzer von SimpleScreenshot bitten, das Update abzuwarten, damit das auch mal getestet wird.

Für alle “Neueinsteiger” gibt es aber wie gewohnt auf der Projektseite die aktuellste Version.

Zur Download Seite…

Ich weiss, ich hab lange gebraucht, aber wie man an der Versionsnummer sieht, gibt es auch viel neues. Das wäre:

• Der Verstecken und Beenden Button wurden ausgetauscht, damit man nicht immer aus versehen auf Beenden klickt.
• Viel bessere Einstellungen
• Übersetzung nicht mehr per Datei, dafür aber deutlich einfacher. Wenn jemand eine Sprache vermisst, einfach melden, ich schicke euch dann die Strings und baue eure Übersetzung ein. (English/Deutsch vorhanden)
• Bilder können automatisch bei Imageshack.us hochgeladen werden (weitere Hoster in Planung, s .u.)
• Bilder können automatisch in Word eingefügt werden (z.B. für einfache Dokumentation)
• Es können auch nur Teile von Fenstern oder dem gesamten Bildschirm aufgenommen werden.
• Als Speicherformat können JPEG/BMP/PNG gewählt werden (JPEG hat noch Fehler, besser nicht benutzen…)
• Die Tastenbelegung ist besser einstellbar
• Automatische Updatefunktion (deaktivierbar)
• Namen per Platzhalter (Datum/Zeit, Name der aktiven Anwendung/Fortlaufende Nummern)
• Vermutlich noch mehr, aber das fällt mir grad nicht ein…

Natürlich ist auch diese Version noch nicht perfekt, und ich habe auch noch ein paar Ideen, die dann mit Version 1.0 kommen werden. Erst kommt aber noch (bald) 0.9.1, denn dieses Version hat noch ein paar Probleme mit JPEG, aber ich wollte die Veröffentlichung nicht schon wieder verschieben… Und so kann ich auch den Updater testen

Besonders ist (meiner Meinung nach) die Funktion, die Bilder automatisch in Word einfügen zu können, soweit ich gehört habe, könne besonders Firmen eine solche Funktion gebrauchen (für Installatiosdokumentationen), und damit will ich mich auch von anderen Screenshot Programmen abgrenzen.

Was noch geplant ist:

• Bugfixes
• Hoster per XML Datei erweitern
• evtl. Text und Pfeile in die Bilder einbauen
• Automatische Kategorien nach Anwendungen
• Kategorien = Unterordner
• Einfache eigene Kategorien

Bekannte Bugs:

• Probleme mit JPEGs
• Evtl. kleine Bugs beim Speichern in Word
• Das automatischer anzeigen einer Meldung bei einen Absturz geht nicht

Diese Bugs werden aber mit den nächsten Version, die dann per Update kommt hoffentlich behoben

Wenn ihr selber noch Wünsche habt: Ab in die Kommentare damit!

Aber damit es auch was zu sehen gibt kommen jetzt noch ein paar Screenshots:

Das Hauptfenster

Die Einstellungen

Nur einen Bereich aufnehmen…

Mehr Einträge im Kontextmenü

Nun aber das wichtigste: Der Download:
Zur Download Seite…

Hier ist der Changelog:

Bugfixes:

• kein Absturz mehr, wenn MP3s geöffnet werden
• Dateien werden nach schließen des Fensters freigegeben
• kleinere interne Änderungen

Änderungen:

• Neuer Hintergrund(danke an whsprogger)
• Mehr Bilder, weniger Buttons

Neue Features:

• Es werden jetzt Plugins unterstützt.
  • Mitgelieferte Plugins:
    • Multimedia
      • Videos
      • Musik
      • Bilder
    • Office (erfordert Microsoft Office)
      • Word
    • Text
      • alle Textdateien
    • PDF
      • PDF
• TrayIcon zum Beenden
• Automatischer Updater

Der Updater sucht einmal pro Tag nach Updates auf meinem Server und wird Sie automatisch installieren. Noch ein paar Worte zu den Plugins:

Das Office Plugin erfordert ein installiertes Microsoft Office, wenn das nicht gefunden wird, wird das Plugin nicht geladen. Zudem kann dieses Plugin nur Word Dateien öffnen, und auch die nur als Text(ohne Formatierung). Wenn sich jemand mit dem Anzeigen von Office Dokumenten auskennt, ich würde mich über Tipps (oder ein Plugin) freuen!

Das Text Plugin bezieht die Dateierweiterungen, die es anzeigen soll aus der Datei “text_ext-txt”. Diese Datei kann man anpassen um weitere Endungen mit diesem Plugin anzuzeigen. Danach ist ein Neustart von FastView nötig.

Ich habe versucht das Programm für x64 Prozessoren zu kompilieren, was mir aber aufgrund der vielen abhängigen DLLs nicht gelungen ist. Das alte lief ja nicht auf 64-Bit Systemen, und auch diese Version benutzt noch viele Pointer, die ja auf 64-Bit Systemen größer sind. Evtl. kann Windows das aber duch WoW64 ausgleichen. Wenn nicht bitte ich um Verzeihung, aber dann ist da wohl (mit vertretbarem Aufwand) nicht zu machen…

Als nächstes werde ich auch noch eine Anleitung zum erstellen von Plugins veröffentlichen. Wer noch Ideen hat, oder Fehler findet kann gerne einen Kommentar hinterlassen, ich werde mich darum kümmern!

Weitere Informationen, und vor allem den Download findet ihr auf der Projekt Seite:

Zur Projekt Seite…

Der Performancegewinn hängt von der Größe der Karte ab, bei mir hat es 100 FPS gebracht. Das ist weniger als es erstmal klingt, den ob ein Spiel nun mit  300 oder 400 Frames pro Sekunde läuft kann man nicht merken… Trotzdem hatte ich schon lange vor diese Technik einzubauen. Die Änerung ist eigentlich auch nur sehr klein:

for (int i = (int)Camera.CameraPosition.X / 32; i < Math.Min(((int)Camera.CameraPosition.X / 32) + 26, Tiles.Count); i++)
 {
 // Alle Spalten durchlaufen
 for (int j = (int)Camera.CameraPosition.Y / 32; j < Math.Min(((int)Camera.CameraPosition.Y / 32) + 20, Tiles[0].Count); j++)
 {

statt

for (int i = 0; i < Tiles.Count; i++)
 {
 // Alle Spalten durchlaufen
 for (int j =0; j <  Tiles[0].Count; j++)
 {

Und weiter geht die Bugsuche….

Zur Download Seite…

Zur Download Seite…

Hier ist der Changelog:

• Kontexmenü am Trayicon
• Screenshot-Taste wählbar
• Autostart Option
• 32Bit Farben in den Vorschaubildern
• Neues Icon
• Regler zum Einstellen der Vorschaubildgröße
• Doppelklick auf ein Bild öffnet es
• Wenn ein String nicht in der Originalsprache gefunden wird, wird Englisch verwendet(statt Deutsch)

Es gibt aber auch ein paar bekannte Bugs:

• Die Vorschaubilder werden immer quadratisch dargestellt, der Fehler liegt aber wohl im .Net Framework
• Bei der Tastenauswahl kann man einige Tasten auswählen, die nicht funktionieren, und einige Tasten sind doppelt. Leider ist das die einzige Enum mit allen Tasten im .Net Framework, bitte nur “sinnvolle” Tasten benutzen!

Vielen Dank auch noch mal an “markus” der die Ideen zu fast allen Neuerungen hatte. Leider konnte ich das vorgeschlagene Windowskontextmenü nicht umsetzen, weil Windows da scheinbar keine Funktiom für eingebaut hat… Und auch der Bug, dass man ein Bild nicht sofort öffnen kann, tritt bei mir nicht auf. Evtl. ist meine Festplatte schneller? Ich denke aber nicht, dass das jemanden stören wird, weil man die Screenshots ja eigentlich nicht sofort öffnet.

Zur Download Seite…