Arduino - Barometrischen Höhensensor GY-65 auslesen

(English version) Eine weit verbreitete Möglichkeit, relative Höhen zu messen ist das Benutzen eines barometrischen Höhensensors. Dieser misst einfach den Druck und aus der barometrischen Höhenformel (Wikipedia) lässt sich daraus eine Höhe bestimmen. Da der Luftdruck sehr stark vom Tag abhängt wird normalerweise an einer bekannten Höhe der Sensor kalibriert und dann die restlichen Höhen relativ zu dieser Höhe und dem dort gemessenen Druck berechnet. Das liefert Höhen mit einer Genauigkeit von bis zu 1 Meter.

Wenn man bei ebay nach GY-65 sucht, findet man den entsprechenden Sensor für ca. 5 Euro. Der Sensor hat ein normales I2C-Interface, sodass nur 2 Kabel nötig sind. Für den Arduino braucht man dann die I2Cdev Library, die gibt es hier zum runterladen. Der Quellcode an sich ist maximal simpel, zuerst wird der Sensor initialisiert, dann wird eingestellt, dass der Druck gemessen werden soll und anschließen der Druck ausgelesen und daraus die Höhe berechnet. Ein komplettes, simples Beispielprogramm sieht so aus:

#include <I2Cdev.h>
#include "BMP085.h"
#include <Wire.h>

BMP085 barometer;

double pressure;
double altitude;


void setup() {
  Wire.begin();
  
  Serial.begin(9600);
  Serial.println("starting...");
    
  //initialize the barometer
  barometer.initialize();
}

void loop()
{
  // request pressure (3x oversampling mode, high detail, 23.5ms delay).
  // Let's just wait a bit more to be sure...
  barometer.setControl(BMP085_MODE_PRESSURE_3);
  delay(30);
  // read calibrated pressure value in Pascals (Pa)
  pressure = barometer.getPressure();
  // calculate absolute altitude in meters based on known pressure
  // (may pass a second "sea level pressure" parameter here,
  // otherwise uses the standard value of 101325 Pa)
  altitude = barometer.getAltitude(pressure); 
  
  // print back the calculated altitude
  Serial.println(altitude);
  // do this every second
  delay(1000);
}

I2C OLED Display

(english version) Wer bei Ebay nach "Arduino OLED Display" sucht, stößt auf ein OLED-Display mit einer Bildschirmdiagonale von ca. 1 Zoll und einer Auflösung von 128x84 Pixel. Das Display ist für weniger als 4 Euro zu haben. Angesteuert wird es über I2C. 1 Zoll ist natürlich nicht viel, aus Interesse habe ich mir das Display aber dennoch bestellt. Damit man sich vorstellen kann, wie klein es wirklich ist, habe ich eine Münze zum Vergleich daneben gelegt:

Dank Ansteuerung über I2C ist die Verkabelung denkbar übersichtlich: neben der Spannungsversorgung sind nur zwei Kabel für den I2C-Bus nötig, das wars. Nun stellt sich natürlich die Frage: wie steuere ich das Ding an? Nach kurzer Recherche habe ich heraus gefunden, dass es sich bei dem Display um einen Nachbau des OLED-Displays mit der Bezeichnung SSD1306 von Adafruit handelt. Dafür bietet Adafruit eine fertige Arduino-Library an, welche HIER erhältlich ist. Außerdem muss die Adafruit-GFX-Library herunter geladen und installiert werden. In der Arduino IDE findet sich dann unter "Adafruit_SSD1306" das Beispiel "ssd1306_128x64_i2c". Wer dieses Beispiel nun einfach so 1:1 auf den Arduino überträgt sieht erstmal: gar nichts. Das China-Display hat eine andere I2C-Adresse wie das Original von Adafruit, daher muss in der setup()-Funktion eine kleine Änderung durchgeführt werden: die Adresse muss von 0x3D in 0x3C geändert werden. Aus

  display.begin(SSD1306_SWITCHCAPVCC, 0x3D);  // initialize with the I2C addr 0x3D (for the 128x64)

wird

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x64).

Dann dann kann das Beispiel auf den Arduino übertragen werden. Ihr solltet jetzt eine kleine Demonstration der verschiedenen Funktionen der GFX-Library auf dem Display sehen. Da die Funktionen und somit auch das Beispiel sehr umfangreich sind, werde ich sie nicht im Detail erläutern. Im Prinzip sind die Funktionen im Beispiel alle selbsterklärend. Bei Unklarheiten schaut in die Header-Datei der GFX-Library, dort ist auch erläutert, welche Parameter die einzelnen Funktionen erwarten. Es gibt die Möglichkeit Text auszugeben, außerdem lassen sich Linien und diverse Formen (Rechteck, Dreieck, ...) mit und ohne Füllung zeichnen. Auch das Invertieren des Bildschirms sowie das Scrollen sind möglich.

Außerdem kann ein vordefiniertes Bitmap ausgegeben werden. Dies möchte ich kurz näher erklären:

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#define XPOS 50
#define YPOS 25
#define BITMAP_HEIGHT 16 
#define BITMAP_WIDTH  16 
static const unsigned char PROGMEM bitmap[] =
{ B00000001, B10000000,
  B00000010, B01000000,
  B00000100, B00100000,
  B00001000, B00010000,
  B00010000, B00001000,
  B00111111, B11111100,
  B00101000, B00010100,
  B00100100, B00100100,
  B00100010, B01000100,
  B00100001, B10000100,
  B00100010, B01000100,
  B00100100, B00100100,
  B00101000, B00010100,
  B00110000, B00001100,
  B00111111, B11111100,
  B00000000, B00000000 };

void setup()   {                

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x64)
  
  //clear display buffer
  display.clearDisplay();
  //draw a bitmap stored in variable bitmap with given size at XPOS, YPOS in color white
  display.drawBitmap(XPOS, YPOS, bitmap, BITMAP_WIDTH, BITMAP_HEIGHT, WHITE);
  display.display();
 
}


void loop() { 
}

In diesem Beispiel zeichnen wir ein Bitmap mit einer Größe von 16x16 Pixeln. Die Größe des Bitmaps kann natürlich angepasst werden. Das Bitmap muss in einem Character-Array hinterlegt sein. Besonders wichtig ist hier bei der Deklaration das Schlüsselwort "PROGMEM". Es sorgt dafür, dass die Variable im Flash-Speicher des Arduinos abgelegt wird. Dies wird von der Library so erwartet. Im Beispiel speichern immer jeweils zwei Character in insgesamt 16 Bit den Inhalt einer Zeile. Ist ein Bit gesetzt, wird beim später Zeichnen ein Pixel gesetzt. Der Übersicht halber habe ich im Code Zeilenumbrüche eingefügt. Eine Zeile im Code entspricht nachher eine Zeile des Bitmaps. Zur Darstellung des Bitmaps wird dann der Befehl drawBitmap() aufgerufen. Als Parameter werden übergeben: die X- und Y-Position des Bitmaps, die Variable, in der das Bitmap gespeichert ist, die Breite und die Höhe des Bitmaps sowie die Farbe (WHITE oder BLACK), in der ein gesetzter Pixel dargestellt werden soll.
Das Ergebnis:

Einen Pinsel wieder anspitzen

(English version) Ein neu gekaufter Pinsel ist normalerweise sehr spitz und auch etwas hart, sodass man damit sehr gut feine Linien malen kann. Nach einer Weile fangen die Häärchen aber an, in alle Richtungen abzustehen, sodass man den Pinsel eigentlich nicht mehr benutzen kann. Um den Pinsel wieder so spitz wie am Anfang zu bekommen kann man einen ganz einfachen Trick benutzen.

Ein benutzer Pinsel mit welchem keine feinen Malarbeiten mehr möglich sind.

Zuerst wird Zuckerwasser hergestellt. Einfach Wasser und Zucker mischen und gut umrühren. Danach wird der Pinsel in die Lösung getaucht. Die Oberflächenspannung hält die Pinselhaare dann schon grob zusammen.

Pinselspitze mit Zuckerlösung. Die Haare werden von alleine zusammengehalten (Oberflächenspannung).

Um den Pinsel jetzt perfekt spitz zu bekommen streicht man ihn sehr vorsichtig ab, dadurch wird er noch spitzer. Wenn man ihn jetzt noch trocknen lässt bildet sich wieder die Spitze wie bei einem neu gekauften Pinsel. Ich benutze Pinsel der Größe 00, die gibt es meistens ganz billig (1 €) in jedem Spielwarenhandel. Wenn man den Pinsel dann entsprechend pflegt bleibt die Spitze auch so perfekt und man kann ihn nahezu unendlich lange benutzen.

Der wieder spitze Pinsel.

Eine Einführung zu Tabletops

(English version) Da ich mich selber seit einiger Zeit mit Tabletops beschäftige, möchte ich heute eine Einführung dazu posten, ich finde nämlich dass sie die beste, spannendste und vielseitigste Art von Gesellschaftsspielen sind. Tabletops gibt es in vielen verschiedenen Welten, ich will jetzt speziell auf Fantasy eingehen. Die Situation bei Fantasy ist technologisch eine Welt im Mittelalter, wo gerade Schießpulver erfunden wurde, jedoch gibt es verschiedene Völker wie Zwerge, Elfen, Orks, Goblins, Drachen und vieles mehr. Außerdem ist hier Magie im Spiel, es gibt also z.B. Zauberer die Feuerbälle schießen können.

Ein Tabletop besteht aus Figuren welche man auf einem Tisch bzw. einer Spielplatte platziert. Bekannte Hersteller solcher Figuren sind für Fantasy z.B. Kings of War von Mantic Games, Warhammer von Games Workshop, Dwarf Wars von West Wind Productions oder Hail Caesar von Warlord Games. Ich persönlich nutze die Miniaturen von Mantic Games, da diese sehr billig sind und einige interessante Aspekte aufweisen wie z.B. Erzengel oder Dachsreiter, welche von den anderen Herstellern nicht angeboten werden.

Die Grundidee eines Tabletops ist dass zwei (oder auch mehr) Armeen sich gegenüberstehen und dann anfangen zu Kämpfen, also prinzipiell ähnlich wie z.B. die Computerspiele der Total War-Reihe.

Malen und Bauen
Wenn man nun mit Tabletops anfangen will braucht man zuerst eine Armee. Hier gibt es meist Starter-Sets, welche bei Mantic Games z.B. je nach Set eine oder zwei Armeen, Würfel und das Regelbuch beinhalten. Dieses Set besteht dann aus einzelnen Plastik-Teilen welche zusammengebaut und angemalt werden müssen. Hier gibt es dann den ersten Konfliktpunkt: Sollte man die Figuren zuerst aufbauen oder zuerst anmalen? Ich persönlich finde, dass es geschickter ist, zuerst anzumalen, wenn die Figuren bereits zusammengebaut sind kann man an manche Stellen schwieriger ankommen. Andererseits würde ich, wenn man zuerst anmalt, empfehlen, nach dem Zusammenkleben mit den entsprechenden Farben über die Klebestellen zu malen, sodass hier die Farbe durchgängig ist. Ein anderes wichtiges Argument dafür, zuerst anzumalen, ist dass ansonsten oft auch mit den zusammengebauten Figuren gespielt wird, das Anmalen aber immer weiter nach hinten verschoben wird. Dies führt dann oft dazu, dass ganze Armeen nicht angemalt sind, und das sieht wirklich erbärmlich aus. Wenn man zuerst anmalt, kann man mit den Figuren auch erst spielen, wenn alles fertig angemalt ist, daher gibt dies schon automatisch die Motivation, alles anzumalen.

Zum Zusammenkleben benutze ich den bekannten Revell Contacta Modellbaukleber, dieser ist ziemlich preiswert in jedem Spielwarengeschäft erhältlich. Farben benutze ich auch von Revell, ich habe zuerst die Email-Farben benutzt, diese weisen eine sehr gute Deckkraft (außer bei weiß) auf, sind aber eher dickflüssig und schwer zu verarbeiten, da sie nicht mit Wasser verdünnbar sind. Ich bin dann später auf die Revell Aqua Farben umgestiegen, diese lassen sich hervorragend malen und auch verdünnen, sodass man auch Maltechniken wie Tuschen ganz einfach durch das starke Verdünnen einer Farbe mit Wasser erreichen kann. Außerdem sollen die Revell Aqua Farben schneller trocknen (4 Stunden vs. 1 Stunde).

Wenn nun die Armee aufgebaut ist, kann man mit dem Spielen anfangen. Dafür braucht man noch einen Gegner mit einer Armee oder man legt sich selbst 2 Armeen zu und lässt diese dann gegeneinander kämpfen. Als Spielunterlage kann alles dienen, angefangen beim Teppich oder eine Tisch bis hin zu einer grünen Filz-Matte, speziellen Spielmatten oder modularem Gelände, wie ich es hier in diesem Blog bereits beschrieben habe. Für den Anfang reicht jedoch wirklich ein Tisch mit ein paar Platzhaltern als Gelände (ein Blatt Papier als Sumpf, ein Buch als Hügel, etc.

Spielregeln
Ich möchte nun ein wenig auf die Regeln dieser Spiele eingehen, speziell denen von Kings of War (welche hier recht weit unten auch online einsehbar sind). Grundsätzlich wird rundenbasiert gespielt, ein Spieler nach dem anderen. Jeder Spieler hat dann in seinem Zug drei Teile.

Bewegung
Zuerst werden Bewegungen ausgeführt, hier hat jede Einheit einen Bewegungs-Wert in Zoll, welcher angibt, wie weit die Einheit sich bewegen kann. Hier gibt es dann spezielle Regeln für den Angriff auf gegnerische Einheiten, welche in den Regelbüchern explizit erklärt sind.

Fernkampf
Nach dieser Bewegungs-Phase kommt die Fernkampf-Phase, hier schießen dann alle Einheiten, welche sich nicht im Nahkampf befinden. Es gibt sowohl normale Fernkampf-Infanterie als auch Artillerie und Magie, dies wird alles in dieser Runde behandelt. Nehmen wir beispielsweise Zwergen-Armbrustschützen (Ironwatch) von Kings of War. Diese haben einen Fähigkeitswert im Fernkampf (Ra) von 5+ und 10 Angriffe (At). Das bedeutet nun, dass für jeden Angriff ein Würfel geworfen wird (also nimmt man 10 Würfel in die Hand) und jedes Ergebnis welches 5 oder höher (also 5 oder 6) ist, zählt als ein Treffer. Als nächstes wird die Verteidigung des Gegner betrachtet. Diese Einheiten schießen nun z.B. auf eine Einheit aus Ork-Kriegern (Greatax), welche einen Verteidigungs-Wert (De) von 4+ haben. Man nimmt nun alle Würfel, welche getroffen haben und wirft diese erneut. Für jeden Würfel der nun 4+ (also 4 oder höher) zeigt wird der Einheit ein Punkt Schaden zugefügt. Nachdem der Schaden ausgewürfelt wurde muss getestet werden wie stark die Einheit beschädigt ist, ob sie noch kämpfen kann oder völlig zerstört ist. Dieses nennt man einen Nerve Test, welcher weiter unten beschrieben wird.

Nahkampf
Nach der Fernkampf-Phase kommt die Nahkampf-Phase. Nahkämpfe werden in der Bewegungsphase initiiert, indem man seine Einheiten in Kontakt mit feindlichen Einheiten bringt. Die Nahkampf-Phase funktioniert gleich wie die Fernkampf-Phase, nur dass der Nahkampf-Fertigkeitswert statt dem Fernkampf-Fertigkeitswert benutzt wird. Hier werden nun auch wieder Treffer und daraus der verursachte Schaden berechnet und am Ende der Nahkampf-Phase ein Nerve Test durchgeführt.

Nerve Test
Nach dem Fernkampf und nach dem Nahkampf wird ein sogenannter Nerve Test durchgeführt. Der Nerve Test entscheidet ob eine Einheit noch kämpfen kann oder stark beschädigt ist, moralisch am Ende ist oder völlig ausradiert wurde. Dazu werden zwei Würfel geworfen und zu dem Würfelergebnis der gesamte Schaden der dieser Einheit zugefügt wurde addiert. Jede Einheit hat einen Nerve-Wert (Ne), welcher aus zwei Zahlen besteht. Ist die Summe aus Würfelergebnis und Schaden größer oder gleich dem ersten Wert, so ist diese Einheit moralisch am Ende und kann in der nächsten Runde lediglich Bewegungen wie drehen oder rückwärts ausführen. Fernkampfeinheiten können in der nächsten Runde nicht schießen. Eine Runde danach ist dieser Effekt aber wieder abgeschüttelt. Falls die Summe so hoch wie der zweite Wert ist, bedeutet das, dass die Einheit vernichtet wurde. Entweder wurden alle Soldaten getötet oder sie haben die Flucht ergriffen und sich in alle Himmelsrichtungen zerstreut - diese Einheit wird nicht mehr kämpfen und wird vom Schlachtfeld entfernt.

Nach diesen Prinzipien funktioniert also ein Tabletop. Natürlich bin ich nicht auf alle Regeln einzeln eingegangen, wer also wirklich ein Tabletop spielen will sollte sich unbedingt das Regelbuch anschauen. Die verschiedenen Spiele haben teilweise verschiedene Regeln, ich persönlich mag jedoch die Regeln von Kings of War, da sie sehr einfach gehalten sind und trotzdem viel taktische Tiefer erlauben, sodass das Spiel nicht darin ausartet, Sonderregeln gegeneinander abzuwägen und ständig zum Regelbuch zu greifen.

Tabletops gibt es auch in anderen Welten, so gibt es z.B. Science-Fiction Tabletops welche nach ziemlich ähnlichen Regeln funktionieren, aber auch historische Varianten, komplett ohne Magie oder in anderen Maßstäben z.B. als Raumschiff-Schlacht oder Seeschlacht. Mir gefällt jedoch Kings of War von Mantic Games am besten, der Maßstab, also 28mm, ist ein guter Kompromiss aus Größe und der Feinheit der Figuren und ist auch der am weitesten verbreitete Maßstab an Miniaturen. Ich hoffe, ich konnte bei einigen Leuten Interesse an Tabletops wecken, sodass noch mehr Menschen diese unglaublich vielseitige und interessante Art der Gesellschaftsspiele für sich entdecken können.

Tabletop Gelände - Wasser

(English version) Die Grundlagen des Geländebauens sind normalerweise relativ einfach. Modell bauen, anmalen, Gras/Deko drauf. Natürlich kann hier in die Detailgestaltung unendlich viel Zeit gesteckt werden, jedoch ist das Grundprinzip klar. An was ich mich bisher nicht gewagt hatte war Wasser. Die einfachste Version von Wasser ist natürlich einfach eine Fläche blau glänzend anzumalen, fertig. Das sieht dann aber meist nicht so realistisch aus und zieht dann das komplette andere, schön gestaltete Gelände herunter.

Für Wasser gibt es einige kommerzielle Lösungen, welche ich alle nicht ausprobiert habe. Ich habe stattdessen Silikon benutzt, welches es billig, bei z.B. Obi gibt (das hier habe ich verwendet: Obi-Link). Das Ergebnis sieht ziemlich gut aus.

Beim Verarbeiten sollte man beachten, dass es sehr schnell trocknet und auch sehr an den Fingern klebt. Eine wellige Oberfläche wie sie hier zu sehen ist, ist also leicht zu erschaffen, eine glatte schon schwieriger. Außerdem sollte man beachten, dass das Silikon nicht perfekt transparent ist. Daher würde ich empfehlen, das Silikon nur für eine sehr dünne Schicht und den Wellen-Effekt zu verwenden. Wenn das Geländestück auch noch Gras haben soll, sollte dieses möglichst vor dem Silikon angebracht werden, die Grasteilchen kleben extrem am Silikon und sind kaum abzukriegen. Wer auch tiefere Gewässer damit machen möchte kann hier ein Testobjekt von mir sehen:

Das Testobjekt ist etwa 1 cm tief. Die Oberfläche ist deutlich glatter aber eine schöne Spiegelglatte Oberfläche, wie für einen See kriegt man damit nicht hin. Außerdem ist bei größeren Volumina zu beachten, dass das Silikon, wenn es mal angefangen hat zu trocken sich nicht mehr mit sich selber verbindet, dies führt an den Übergängen zu weißen Bereichen (auch hier in den Bildern zu sehen), was meines Erachtens nicht schön aussieht.
Für den Preis kann man allerdings absolut nichts gegen das Silikon sagen, kommerzielle Wassereffekte sind da doch deutlich teurer.

Tabletop Belagerungsausrüstung Teil I: Die Sturmleiter

(English version) Da ich schon erklärt habe, wie man eine Mauer und einen Turm bauen kann, muss auch irgendwann die Seite der Belagerer dran sein. Als erstes will ich mit dem am einfachsten zu bauenden Gerät anfangen, nämlich der Sturmleiter.

Um die Sturmleiter zu bauen braucht man ein Holz der Querschnittsfläche 3x3 mm, ich habe hier Balsaholz benutzt. Für eine Leiter braucht man 72 cm. Das Holz wird nun zurechtgeschnitten. 2 lange Teilen der Länge 18 cm und 9 kurze Teile der Länge 4 cm. Nun wird auf den langen Teilen an den Positionen 1,3,5,... cm markiert, danach werden die kurzen Teile drauf geklebt. Damit ist die Leiter eigentlich schon fertig, man kann diese nun noch mit brauntönen anmalen (Wasserfarben sind gut geeignet, da man die Holzstruktur immer noch durchsieht).

Tabletop Gelände - Hügel

(English version) Mit diesem Post will ich ein paar neue Geländeplatten vorstellen: Hügel. Wie alle meine Geländeplatten baue ich die Hügel aus Styropor. Als Grundlage dafür dient die Basisplatte aus Holz mit den Füßen, auf diese wird dann der Rest aufgeklebt.

Ich habe die Höhe der Hügel als 5 cm festgelegt, das passt meiner Meinung nach ziemlich gut zu den 28 mm Modellen. Kommen wir nun zur Kante zwischen zwei Hügeln. Diese muss ja an allen Hügelecken und -Kanten gleich sein, dass man das Gelände beliebig kombinieren kann. Ich baue die Hügel aus 5 Platten mit je 1 cm Dicke auf, welche 8, 9, 10, 11 und 12 cm breit sind. Schematisch sieht das so aus:

Nun kann man daraus die ersten Grundformen bauen: Ecken und Kanten. Für eine Ecke braucht man 5 Teile der Größen 12x12, 11x11, 10x10, 9x9, 8x8. Diese werden an einer Ecke bündig übereinander geklebt.

Das sieht jetzt zwar schon nach einem Hügel aus, allerdings kann man das noch weiter verbessern. Da ich Styropor benutze kann man hier einfach Stücke rausreißen, das hinterlässt dann eine felsige zerklüftete Struktur.

Nun muss der Hügel nur noch angemalt werden: Die Ebenen braun, die Hügelkanten grau. Über alles Graue dann noch mit weiß trockenbürsten, alles Braune begrasen und schon hat man einen wunderschönen Hügel:

Ich persönlich würde empfehlen, mehr Styropor rauszureißen als hier im Bild dargestellt ist (das war mein erster Test, daher ist der Hügel noch nicht so schön). Man kann nun weitere Hügelteile bauen wie z.B. Kanten (wie im Bild oben) oder auch innere Ecken:

Die Hochebene ist einfach ein 6 cm dicker Block Styropor auf eine Holz-Grundplatte geklebt.

Tabletop Gelände - die Burg Teil II: Turm

(English version) Grundsätzlich gibt es 3 Teile, welche jede Burg haben muss: Mauern, Türme und mindestens ein Tor. Kommen wir also zum zweiten Teil, dem Turm.

Zuerst wieder zum konzeptionellen: Der Turm soll an beiden Seiten mit der Mauer verbunden sein. Außerdem habe ich mich bei der Grundfläche des Turmes auf 12x12 cm festgelegt. Das heißt dass an jeder Seite des Turmes noch 4 cm Mauer sein müssen.

Den Turm habe ich aus drei 6 cm dicken Styropor-Platten hergestellt, diese sind auf 12x12 cm zugeschnitten und dann übereinander gestapelt.

Als nächstes werden nun die kleinen Mauerstücke an der Seite gebaut. Dazu werden zwei 12x4 cm große Blöcke aus dem 6 cm dicken Styropor geschnitten. Als letzten Arbeitsschritt wird nun noch die Plattform oben gebaut: Eine 14x14 cm große Platte aus 1 cm dickem Styropor, welche mit Zinnen (wie bei der Mauer) bestückt wird. Ich habe 2 Teile der Länge 14 cm und 2 Teile der Länge 12 cm kombiniert um die Zinnen wie unten abgebildet herzustellen. Außerdem braucht es noch kleine Zinnen für die seitlichen Mauerstücke, diese sind einfach 4 cm breit und so gebaut, dass sie mit dem Mauer-Stück zusammen passen.

Anschließend muss der Turm noch angemalt werden, dies funktioniert analog zur Vorgehensweise im Post zur Mauer.

Tabletop Gelände - die Burg Teil I: Mauer

(English version) Belagerungen fand ich schon immer sehr interessant, daher muss es also auch Burgen in meinem Gelände geben. Zuerst will ich nun also mit dem einfachsten Teil der Burg anfangen, dem geraden Mauerstück.

Zuerst muss man sich überlegen, wie die unterschiedlichen Elemente zusammenpassen sollen. Meine Planung war die folgende:

Man sieht links wie die Zinnen aussehen sollen, sodass an einer Verbindungsstelle immer zwei 1 cm breite hohe Teile aufeinander treffen und so ein "normales" 2 cm breites hohes Teil formen:

Die Mauer habe ich aus Styropor gebaut, einmal 6 cm Dicke für den Mauerkörper und dann noch 1 cm Dicke für die Zinnen. All das wird dann zusammen geklebt und angemalt und sieht dann folgendermaßen aus. Vor dem Anmalen:

Die erste Schicht Farbe - ich benutze hier Voll- und Abtönfarbe von Obi (gibt es 0,5 l für 6 Euro, damit sollte man eigentlich eine komplette Burg anmalen können).

Als nächstes wird noch mit weißer Farbe trockengebürstet. Dazu wird einfach der Pinsel in sehr wenig weiße Farbe getaucht, welche dann auf einem Stück Papier größtenteils wieder abgestreift wird. Nun nimmt man den trockenen Pinsel und bürstet über die graue Farbe - das Ergebnis kann man hier sehen:

Ich finde, dass die Struktur vom Styropor (welche durch das Trockenbürsten gut zur Geltung kommt) die Mauer ziemlich gut aussehen lässt. Alternativ kann man auch Styrodur (auch bekannt als XPS) benutzen, dieses hat eine glatte Oberfläche und lässt sich leichter schneiden. Will man nun eine Struktur haben, muss man diese selber reinritzen. Das kann am Ende besser aussehen als beim Styropor ist jedoch teurer und mit mehr Aufwand verbunden.

Tabletop Gelände - ein See

(English version) Einen See zu bauen ist nicht schwer. Zuerst wird eine normale Gelände-Platte gebaut. Danach zeichnet man sich den See auf:

Danach fängt man an, den See aus dem Styropor zu schneiden/reißen:

Nun wird die Platte braun angemalt. Anschließend der See blau. Für ein besseres optisches Ergebnis wird noch Sand an den Rand hinzugefügt:

Zum Schluss noch Gras:

Und wenn man Lust hat kann man noch etwas Islandmoos drauf verteilen:

Tabletop Gelände - die erste Platte

(English version) Wollen wir nun zu der ersten und einfachsten Platte kommen: Grasland. Die Platte sieht so aus:

Sie besteht aus einer 10 mm dicken MDF-Platte und darüber einer 10 mm dicken Styropor-Platte (Dadurch ist es möglich, Strukturen, welche bis zu 1 cm tiefer als die Basis-Höhe sind zu bauen). Ganz oben ist dann eine Schicht Gras drauf. Gras gibt es z.B. billig bei ebay. Um das Gras an der Platte festzumachen verwende ich ein 1:1 Gemisch aus Ponal Holzleim und Wasser. Dadurch kann man den Leim schön über die Fläche verteilen ohne dass der Leim trocknet bevor man überhaupt alles eingeschmiert hat. Als Farbe würde ich Voll- bzw. Abtönfarbe benutzen, diese gibt es in großen Mengen für wenig Geld. Alternativ Spraydosen (Nussbraun), diese kosten jedoch recht viel.

Damit hat man schon eine vernünftige Geländeplatte. Ein Problem was es allerdings noch gibt ist das Halten auf dem Tisch. Benutzt man die Platten nun so, verrutschen sie und es entstehen Lücken. Daher habe ich mir ein möglichst simpletes Prinzip überlegt, sodass die Platten ineinander einrasten. An der Unterseite der Platten gibt es in jeder Ecke ein Dreieck aus Holz was herausschaut, ebenso gibt es eine Einkerbung, welche dann einrastet. Das einzelne Teil sieht so aus:

Ich benutze dafür eine Holz-Latte mit den Maßen 20x10 mm welche ich zu Stücken der Länge 4 und 2 cm zurechtschneide. Das lange Stück kommt mit der langen Seite an eine Diagonale der Platte sodass seine Ecke mit der Ecke der Platte übereinstimmt. Das kurze Stück wird dann auf die andere Seite der Diagonalen geklebt, sodass seine andere Ecke mit der Kante der Platte übereinstimmt.

Wenn zwei Platten nebeneinander liegen sieht das so aus:

Bzw. bei 4:

Als nächstes ist nun noch geplant, kleine Magnete unten an die Platte anzubringen, sodass die Platten sich nicht von alleine auseinander bewegen bzw. sich sogar zusammenziehen und dann perfekt passen. Bei den Magneten warte ich noch auf die Bestellung, wenn diese da ist werde ich weiter darüber berichten.

Hat man erstmal 3 Platten konstruiert ist das anbringen der Hölzer an der Unterseite total einfach: Man legt 3 fertige Platten L-förmig aneinander und legt eine rohe Holz-Platte dazu. Danach klebt man einfach die Hölzer so fest, dass sie exakt in die anderen reinpassen.

Tabletop Gelände - Die Grundlagen

(English version) Für Tabletop-Spiele braucht man nicht zwingend ein Gelände. Normalerweise tut es ein Teppich oder Tisch auch schon. Das funktioniert ganz ok, sieht aber nicht so schön aus und taktische Tiefe, z.B. durch Hindernisse, Hügel, Flüsse und weiteres ist dann auch nicht gegeben.

Um das Optische etwas zu verbessern kann man nun z.B. zu der preisgünstigen Variante einer Spielmatte übergehen. Spielmatten gibt es in verschiedenen Ausführungen, manche mit Gras, andere eher im Wüsten-Look. Alternativ kann man auch einfach ein großes grünes Stück Filz-Stoff benutzen. Für die taktische Tiefe gibt es Geländeteile, welche einfach auf die Matte gestellt werden (z.B. Hügel oder Wälder).

Um nun noch eine Stufe höher zu steigen kann man sich überlegen, das komplette Gelände aus einem Guss zu bauen. Für jemanden der viel Platz hat ist das sicherlich akzeptabel, ansonsten stellt sich die Frage wohin man eine 1,2x1,8 m große Platte hinstellen soll (die auch noch eine unebene und empfindliche Oberfläche hat).

Das Optimale sind nun modulare Spieltische. Diese gibt es von viele Firmen wie z.B. Ziterdes, Citadel oder Kallistra.
Die Geländeteile von Ziterdes oder Citadel sind ziemlich ähnlich, beide bestehen aus 60x60 cm großen Platten, welche auch Hügel beinhalten. Citadel ist dabei deutlich teurer als Ziterdes, beide bieten relativ wenig Vielfalt (es gibt eine Hügelecken, bei Ziterdes auch noch Flüsse, aber mehr nicht), zudem sind die Platten sehr groß, sodass man wenig mögliche Kombinationen hat.
Kallistra finde ich persönlich sehr schön, das Spielfeld besteht aus kleinen Sechsecken, welche dann beliebig miteinander kombiniert werden können (fast wie bei Die Siedler von Catan). Es gibt alle möglichen Teile wie Flüsse, Wege, Brücken, Hügel, Berge und sogar Festungen. Leider ist Kallistra auf den 15 mm Maßstab ausgelegt, das heißt dass man mit 28 mm Figuren auf sehr kleine Türme und Mauerstücke treffen würde. Dies ist auch der einzige Grund, welcher mich davon abgehalten hat, Gelände von Kallistra zu kaufen, wer keine Festungen braucht/will kann also Kallistra-Gelände problemlos für 28 mm benutzen.

Nachdem nun alle verfügbaren Lösungen nicht meinen Anforderungen entsprechen, habe ich mich entschieden, selber Gelände zu bauen. Die Grundidee ähnelt der von Citadel/Ziterdes: Ich benutze Platten, welche modular kombinierbar sind. Allerdings habe ich mich auf eine Kantenlänge von 20 cm festgelegt, um mehr mögliche Kombinationen zu haben. Mein Gelände soll dabei wie das von Kallistra viele verschiedene Aspekte besitzen: Seen, Hügelecken, -Kanten und Hochebenen, Festungen und vielleicht sogar Meer. In den nächsten Posts werde ich erkären wie ich das Gelände gebaut habe bzw. wie man es selber ganz einfach bauen kann (Und dabei auch noch wenig Geld ausgibt). Um einen kleinen Vergleich zu haben möchte ich "Grundpreise" des jeweiligen Geländes vergleichen.

Ziterdes: Eine 60x60 cm Platte (bemalt und ein bisschen Gras drauf) kostet 28 €, wenn man das Set kauft ca. 22 €. Heruntergerechnet auf 20x20 cm sind das 2,4 €.

Citadel: Das Set aus 6 Platten (unbemalt, kein Gras) kostet 230 €, das macht ca. 38 € pro Platte bzw. 4,3 € pro 20x20 cm.

Kallistra: Ein Set aus 21 Platten reicht etwas für 90x120 cm und kostet 50 Pfund, mit Gras 75, was etwa 60/90 € entspricht. Somit kosten hier 20x20 cm etwa 2,2/3,3 €.

Um einen Vergleich mit meinem System zu haben: Für eine 20x20 Platte (Grasland) habe ich ohne Begrasung etwa 85 ct ausgegeben, mit Gras kommt man auf maximal 1 €.

Um jetzt nochmal alles zusammenzufassen: Um einen Tisch mit 180x120 cm abzudecken kostet das Gelände:
Ziterdes: 130 €
Citadel: 230 €
Kallistra: 120/180 €
Selbstbau (mein System): ca. 54 €

Arduino Nano V3.0 Klon mit CH340G in Betrieb nehmen

Bei Ebay gibt es einen Klon des Arduino Nano schon für unter 3 Euro zu kaufen. Meist unter dem Namen "Nano V3.0 ATmega328 CH340G" mit dem Zusatz "for Arduino" oder "Arduino compatible", wie zum Beispiel hier. Bei diesen Klonen kommt als USB-Seriell-Wandler nicht wie beim Original ein FT232R sondern (wie der Name schon erkennen lässt) ein CH340G zum Einsatz. Daher sind auch die Treiber der Arduino IDE ungeeignet, stattdessen muss ein extra Treiber von Hand installiert werden. Dieser kann hier beim Hersteller herunter geladen werden. Sollte der Link direkte nicht mehr funktionieren, einfach nach "ch341ser.zip" suchen. Es sind auch Treiber für MAC oder Linux erhältlich. Ich werde hier nur auf die Installation unter Windows eingehen. Zuerst muss das ZIP-Archiv entpackt werden. Falls die Version für 64bit-Windows benötigt wird, muss dann die Datei "DRVSETUP64.exe" aus dem Ordner "DRVSETUP64" in den darüberliegenden Ordner (der unter anderem die Datei "CH341SER.INF" enthält) kopiert werden. Je nach System muss dann die "SETUP.EXE" (32bit) oder die "DRVSETUP64.exe" (64bit) ausgeführt werden. Dann wird auf "INSTALL" geklickt und der Treiber damit installiert.  Damit die Installation des Treibers reibungslos abläuft, darf das Board dabei NICHT eingesteckt sein. Erst NACH der Installation wird der Arduino Nano eingestöpselt. Er sollte dann von Windows erkannt werden.

C# - Programm zum Lösen von Sudokus

(English version) Ein Sudoku von Hand lösen ist nicht weiter schwer, irgendwann überkommt einen Programmierer aber dann die Lust, ein Programm zu schreiben, was Sudokus selber löst. Die Grundidee ist einfach. Das erste freie Kästchen wird ausgefüllt (mit einer 1). Dann wird geprüft ob das Sudoku noch korrekt ist. Falls ja, wird das nächste Kästchen ausgefüllt, falls nicht wird das vorige Kästchen eins hochgezählt. Das wird wiederholt, bis das Sudoku komplett ausgefüllt ist.

Zuallererst habe ich ein Fenster erstellt, welches das Sudoku anzeigt:

<Window x:Class="SudokuSolver.SudokuShowWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="SudokuShowWindow" Height="550" Width="550">
    <Grid Name="Grid1" HorizontalAlignment="Center" VerticalAlignment="Center">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
            <ColumnDefinition Width="50"></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
            <RowDefinition Height="50"></RowDefinition>
        </Grid.RowDefinitions>

    </Grid>
</Window>

Und der dazugehörige Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

namespace SudokuSolver
{
    /// <summary>
   /// Interaktionslogik für SudokuShowWindow.xaml
    /// </summary>
    public partial class SudokuShowWindow : Window
    {
        public SudokuShowWindow()
        {
            InitializeComponent();
        }

        public int[] numbers;
        public TextBlock[] TextBlocks;

        public void refreshValues(int[] _numbers)
        {
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    if (_numbers[i * 9 + j] != numbers[i * 9 + j])
                    {

                        TextBlocks[i * 9 + j].Text = _numbers[i * 9 + j].ToString();
                    }
                }
            }
        }

        public static SudokuShowWindow newSudokuShowWindow(int[] numbers)
        {
            SudokuShowWindow window = new SudokuShowWindow();
            window.numbers = new int[81];
            window.TextBlocks = new TextBlock[81];
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    window.numbers[i * 9 + j] = numbers[i * 9 + j];
                    TextBlock tb = new TextBlock();
                    tb.Text = numbers[i * 9 + j].ToString();
                    tb.HorizontalAlignment = HorizontalAlignment.Center;
                    tb.VerticalAlignment = VerticalAlignment.Center;
                    Grid.SetRow(tb, i);
                    Grid.SetColumn(tb, j);

                    Thickness thk = new Thickness(0, 0, 0, 0);
                    if (i == 2 || i == 5)
                    {
                        thk.Bottom = 1;
                    }
                    if (i == 3 || i == 6)
                    {
                        thk.Top = 1;
                    }
                    if (j == 2 || j == 5)
                    {
                        thk.Right = 1;
                    }
                    if (j == 3 || j == 6)
                    {
                        thk.Left = 1;
                    }
                    Border border = new Border();
                    border.BorderThickness = thk;
                    border.BorderBrush = Brushes.Black;
                    Grid.SetRow(border, i);
                    Grid.SetColumn(border, j);

                    window.Grid1.Children.Add(border);
                    window.Grid1.Children.Add(tb);

                    window.TextBlocks[i * 9 + j] = tb;
                }
            }
            window.Show();
            return window;
        }


    }
}

Dies wird nun benutzt um das Sudoku anzuzeigen. Das Löseprogramm zeigt das aktuelle Sudoku und öffnet für jede gefundene Lösung ein neues Fenster. MainWindow ist leer, wird lediglich zum Starten des Programmes benötigt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace SudokuSolver
{
    /// <summary>
   /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            Thread thread = new Thread(workLoop);
            thread.Start();
        }

        private SudokuShowWindow window;
        private int numberCounter;
        private int[] initialNumbers;
        private int[] numbers;
        List<int[]> Solutions = new List<int[]>();

        private void workLoop()
        {
            //The initial Sudoku which should be solved
            initialNumbers = new int[81]
            {
                5,3,0,   0,7,0,   0,0,0,
                6,0,0,   1,9,5,   0,0,0,
                0,9,8,   0,0,0,   0,6,0,

                8,0,0,   0,6,0,   0,0,3,
                4,0,0,   8,0,3,   0,0,1,
                7,0,0,   0,2,0,   0,0,6,

                0,6,0,   0,0,0,   2,8,0,
                0,0,0,   4,1,9,   0,0,5,
                0,0,0,   0,8,0,   0,7,9
            };
            numbers = new int[81];
            for (int i = 0; i < 81; i++)
            {
                numbers[i] = 0;
            }

            //Invoke window actions because we are not in the main thread
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                window = SudokuShowWindow.newSudokuShowWindow(initialNumbers);
            }));

            //Position of the "cursor" in the sudoku
            numberCounter = 0;

            int ctr = 0;
            bool noi = false;


            while (true)
            {
                if (isItValid())
                {
                    noi = false;

                    //A valid solution!
                    if (numberCounter > 80)
                    {
                        int[] totalNumbers = new int[81];
                        for (int i = 0; i < 81; i++)
                        {
                            totalNumbers[i] = initialNumbers[i];
                            if (totalNumbers[i] == 0)
                            {
                                totalNumbers[i] = numbers[i];
                            }
                        }

                        bool eq = false;
                        foreach (int[] solution in Solutions)
                        {
                            bool leq = true;
                            for (int i = 0; i < 81; i++)
                            {
                                if (solution[i] != totalNumbers[i])
                                {
                                    leq = false;
                                }
                            }
                            if (leq)
                            {
                                eq = true;
                            }

                        }
                        if (!eq)
                        {
                            int[] tmp = new int[81];
                            for (int i = 0; i < 81; i++)
                            {
                                tmp[i] = totalNumbers[i];
                            }
                            Solutions.Add(tmp);
                        }
                        else
                        {
                            System.Console.WriteLine("Done!");
                            break;
                        }

                        Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            SudokuShowWindow.newSudokuShowWindow(totalNumbers);
                        }));

                        //Check for other solutions?

                        noi = true;
                        while (true)
                        {
                            numberCounter--;
                            if (initialNumbers[numberCounter] == 0)
                            {
                                if (numbers[numberCounter] >= 9)
                                {
                                    numbers[numberCounter] = 0;
                                }
                                else
                                {
                                    numbers[numberCounter]++;
                                    break;
                                }
                            }
                        }
                    }

                    if (numberCounter > 80)
                    {
                        break;
                    }

                    if (numbers[numberCounter] == 0 && initialNumbers[numberCounter] == 0)
                    {
                        iterateOne();
                    }
                    else
                    {
                        if (!noi)
                        {
                            increaseNumberCounter();
                        }
                    }
                }
                else
                {
                    if (numberCounter > 80 || numberCounter < 0)
                    {
                        break;
                    }
                    if (numbers[numberCounter] >= 9)
                    {
                        decreaseOne();
                        Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            int[] totalNumbers = new int[81];
                            for (int i = 0; i < 81; i++)
                            {
                                totalNumbers[i] = initialNumbers[i];
                                if (totalNumbers[i] == 0)
                                {
                                    totalNumbers[i] = numbers[i];
                                }
                            }
                            window.refreshValues(totalNumbers);
                        }));

                    }
                    else
                    {
                        iterateOne();
                    }
                }
                ctr++;
                if (ctr > 1000)
                {
                    ctr = 0;
                    Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        int[] totalNumbers = new int[81];
                        for (int i = 0; i < 81; i++)
                        {
                            totalNumbers[i] = initialNumbers[i];
                            if (totalNumbers[i] == 0)
                            {
                                totalNumbers[i] = numbers[i];
                            }
                        }
                        window.refreshValues(totalNumbers);
                    }));
                    Thread.Sleep(1);
                }
            }
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                window.Close();
            }));
        }

        void increaseNumberCounter()
        {
            numberCounter++;
            while (numberCounter <= 80 && initialNumbers[numberCounter] != 0)
            {
                numberCounter++;
            }
        }

        void iterateOne()
        {
            if (numberCounter > 80)
            {
                return;
            }
            while (initialNumbers[numberCounter] != 0)
            {
                numberCounter++;
            }
            numbers[numberCounter]++;
        }

        void decreaseOne()
        {
            if (numberCounter > 80)
            {
                numberCounter = 80;
            }
            numbers[numberCounter] = 0;
            if (numberCounter == 0)
            {
                return;
            }

            while (numberCounter >= 0)
            {
                numberCounter--;
                while (numberCounter > 0 && initialNumbers[numberCounter] != 0)
                {
                    numberCounter--;
                }
                if (numberCounter < 0)
                {
                    return;
                }
                if (numbers[numberCounter] < 9)
                {
                    numbers[numberCounter]++;
                    return;
                }
                else
                {
                    numbers[numberCounter] = 0;
                }
            }
        }

        bool isItValid()
        {
            int[] totalNumbers = new int[81];
            for (int i = 0; i < 81; i++)
            {
                totalNumbers[i] = initialNumbers[i];
                if (totalNumbers[i] == 0)
                {
                    totalNumbers[i] = numbers[i];
                }
            }
            //Check Horizontal
            List<int> testList;
            for (int i = 0; i < 9; i++)
            {
                testList = new List<int>();
                for (int j = 0; j < 9; j++)
                {
                    if (testList.Contains(totalNumbers[i * 9 + j]))
                    {
                        //Invalid
                        return false;
                    }
                    if (totalNumbers[i * 9 + j] != 0)
                    {
                        testList.Add(totalNumbers[i * 9 + j]);
                    }
                }
            }

            //Check Vertical
            for (int j = 0; j < 9; j++)
            {
                testList = new List<int>();
                for (int i = 0; i < 9; i++)
                {
                    if (testList.Contains(totalNumbers[i * 9 + j]))
                    {
                        //Invalid
                        return false;
                    }
                    if (totalNumbers[i * 9 + j] != 0)
                    {
                        testList.Add(totalNumbers[i * 9 + j]);
                    }
                }
            }
            //Check squares
            for (int ii = 0; ii < 3; ii++)
            {
                for (int jj = 0; jj < 3; jj++)
                {
                    testList = new List<int>();
                    for (int i = ii * 3; i < ii * 3 + 3; i++)
                    {
                        for (int j = jj * 3; j < jj * 3 + 3; j++)
                        {
                            if (testList.Contains(totalNumbers[i * 9 + j]))
                            {
                                //Invalid
                                return false;
                            }
                            if (totalNumbers[i * 9 + j] != 0)
                            {
                                testList.Add(totalNumbers[i * 9 + j]);
                            }
                        }
                    }
                }
            }
            //Valid
            return true;
        }
    }
}