Vorliegende Seite demonstriert die Entwicklung eines dreidimensionalen Schachspiels mit Povray.

Dieses Bild scheint eine aufwendige Entwicklung hinter sich zu haben. Doch der Schein trügt! Die Entwicklung eines 3D−Schachspiels fängt mit der Entwicklung der sechs unterschiedlichen Figurentypen (König, Dame, Läufer, Springer, Turm und Bauer) an. Sind diese entwickelt, müssen sie nur noch mit der richtigen Textur auf einem Schachbrett in Position gebracht werden — und fertig!

Die Entwicklung dieses 3D−Bildes hat nur einen Tag in Anspruch genommen. Das Publizieren der vorliegenden Seite hingegen dauerte deutlich länger. :−(

Besonders bei der Entwicklung der Schachfiguren kommt die CSG−Technik (Constructive Solid Geometry) zur Geltung. Das heißt, dass Schlüsselwörter wie union und difference sinnvoll zum Einsatz kommen.
Beispielsweise stellt eine Schachfigur eine Vereinigung (union) von Kopf, Körper und Fuß dar. Dies hat den Vorteil, dass beim Verschieben (translate) der Schachfigur nicht explizit jeder einzelne Teil der Schachfigur verschoben werden muss. Eine Verschiebung der Schachfigur wird als einzelne Verschiebung der Vereinigung der Figurteile umgesetzt.
Von einer Form kann auch eine andere Form abgezogen (difference) werden.
Um aber mit der Entwicklung der Schachfiguren anfangen zu können, benötigt man erst einmal eine simple Entwicklungsszene (hier develop.pov).

// Grauer Hintergrund background { color rgb <0.5, 0.5, 0.5> } // Kamera (ohne perspektivische Sicht) camera { orthographic location <0.0, 1.5, -3.2> look_at <0.0, 1.5, 0.0> } // Weiße Lichtquelle light_source { <6.0, 8.0, -8.0> color rgb <1.0, 1.0, 1.0> } // Default-Textur (hier knochige Farbe) #default {         texture {                 pigment { color rgb <1.0, 0.99, 0.95> }                 finish { ambient 0.41 }         } }

Diese Entwicklungsszene wird im Folgenden für jeden Figurentyp herhalten. So erscheint jede einzelne Figur in gleichem Licht und in gleicher Farbe; die Kameraeinstellungen sowie die Hintergrundfarbe bleiben unverändert. Mithilfe dieser Entwicklungsszene kann man sich bei der Schachfigurenentwicklung erst einmal nur auf die Formgebung der einzelnen Figurentypen konzentrieren.

Der Bauer (Pawn) ist wohl am einfachsten zu entwickeln. Er benötigt eigentlich nur einen simplen Kopf (sphere), einen simplen Körper (cone) und einen simplen Fuß (torus). Mit dieser Figur kann man schon einmal die Grundproportionen festlegen.

#declare Pawn = union {         // Head         sphere { <0.0, 1.5, 0.0>, 0.5 }         // Body         cone { <0.0, 0.1, 0.0>, 0.6, <0.0, 1.3, 0.0>, 0.2 }         // Foot         torus { 0.6, 0.1 translate <0.0, 0.1, 0.0> } }

Diese Deklaration führt noch zu keinem 3D−Resultat. Erst mit der anfangs eingeführten Entwicklungsszene erhält man eine brauchbare 3D−Darstellung des Bauern (develop.pawn.pov). Dies gilt auch für die anderen Figuren.

include "develop.pov" include "pawn.pov" Pawn

Der König (King) wird mit einem Kreuz auf dem Kopf dargestellt. Um die Wichtigkeit des Königs gegenüber den Leichtfiguren hervorzuheben, bekommt sein Körper noch einen zusätzlichen Ring (torus).

#declare King = union {         // Head         sphere { <0.0, 1.7, 0.0>, 0.65 }         // Königskreuz         union {                 box { <-0.1, -0.3, -0.1>, <0.1, 0.3, 0.1> }                 box { <-0.3, -0.1, -0.1>, <0.3, 0.1, 0.1> }                 translate <0.0, 2.6, 0.0>         }         // Body         cone { <0.0, 0.1, 0.0>, 0.8, <0.0, 1.2, 0.0>, 0.3 }         torus { 0.5, 0.1 translate <0.0, 0.7, 0.0> }         // Foot         torus { 0.8, 0.1 translate <0.0, 0.1, 0.0> } }

Die Dame (Queen), die stärkste Figur auf dem Brett, bekommt eine diademähnliche Krone auf ihren Kopf. Ihre Stärke wird ebenfalls mit einem zusätzlichen Ring um den Körper ausgedrückt.

#declare Queen = union {         // Head         sphere { <0.0, 1.7, 0.0>, 0.65 }         // Diademähnliche Krone         difference {                 cone { <0.0, 1.95, 0.0>, 0.55, <0.0, 2.7, 0.0>, 0.8 }                 cone { <0.0, 1.8, 0.0>, 0.0, <0.0, 2.8, 0.0>, 0.8 }                 union {                         cylinder { <-2.0, 3.3, 0.0>, <2.0, 3.3, 0.0>, 0.85 }                         cylinder { <0.0, 3.3, -2.0>, <0.0, 3.3, 2.0>, 0.85 }                         rotate <0.0, 45.0, 0.0>                 }         }         // Body         cone { <0.0, 0.1, 0.0>, 0.8, <0.0, 1.2, 0.0>, 0.3 }         torus { 0.5, 0.1 translate <0.0, 0.7, 0.0> }         // Foot         torus { 0.8, 0.1 translate <0.0, 0.1, 0.0> } }

Üblicherweise sieht der Läufer (Bishop) beinahe so aus wie der Bauer, jedoch mit drei kleinen Unterschieden. Der Kopf des Läufers ist länglich, der des Bauern hingegen nicht. Außerdem bekommt dieser Kopf einen rechteckigen, schrägen Einschnitt (difference) und einen kleinen Bommel.

#declare Bishop = union {         // Head         // Der Bommel         sphere { <0.0, 2.6, 0.0>, 0.15 }         difference {                 sphere {                         <0.0, 1.5, 0.0>, 1.0                         scale <0.6, 1.0, 0.6>                 }                 // Rechteckiger, schräger Einschnitt                 box {                         <0.0, 0.0, -1.0>, <0.2, 1.0, 1.0>                         rotate <0.0, 0.0, -20.0>                         translate <0.0, 1.5, 0.0>                 }         }         // Body         cone { <0.0, 0.1, 0.0>, 0.8, <0.0, 1.2, 0.0>, 0.2 }         // Foot         torus { 0.8, 0.1 translate <0.0, 0.1, 0.0> } }

Lange habe ich darüber nachgedacht, ob ich dem Turm (Rook) einen quadratischen Grundriss geben soll oder nicht. Schließlich kam ich zu dem Schluss, dass dies einen zu extremen Stilbruch geben würde. Deshalb blieb ich auch hier bei einem kreisrunden Grundriss. Um die Charakteristik des Turmes besser hervorzuheben, bekommt er — ähnlich wie der Läufer — noch einen rechteckigen Einschnitt (difference) im Kopfteil.

#declare Rook = union {         // Head         difference {                 cone { <0.0, 1.3, 0.0>, 0.7 <0.0, 2.3, 0.0>, 0.8 }                 cone { <0.0, 1.9, 0.0>, 0.5 <0.0, 2.9, 0.0>, 0.6 }                 box { <-0.2, 2.0, -1.0>, <0.2, 2.4, 1.0> }         }         // Body         cone { <0.0, 0.1, 0.0>, 0.8, <0.0, 1.6, 0.0>, 0.5 }         // Foot         torus { 0.8, 0.1 translate <0.0, 0.1, 0.0> } }

Die wohl am schwersten zu entwickelnde Schachfigur dürfte der Springer (Knight) sein. Körper und Fuß bleiben wie gehabt — die gesamte Komplexität bleibt am Kopf hängen. Dieser wird durch einen großen Zylinder begrenzt, von dem alles Nötige abgezogen (difference) wird.

#declare Knight = union {         // Head         difference {                 cylinder { <0.0, 0.0, -0.4>, <0.0, 0.0, 0.4>, 1.2 }                 cylinder { <0.0, 0.0, 0.3>, <0.0, 0.0, 0.5>, 1.0 }                 cylinder { <0.0, 0.0, -0.5>, <0.0, 0.0, -0.3>, 1.0 }                 plane { <3.0, 1.0, 0.0>, -0.5 }                 box {                         <-2.0, 0.0, -1.0>, <-0.5, -2.0, 1.0>                         rotate <0.0, 0.0, -70.0>                         scale <0.9, 1.5, 1.0>                 }                 box {                         <-0.2, 0.0, -1.0>, <1.3, -2.0, 1.0>                         rotate <0.0, 0.0, -85.0>                         scale <0.5, 1.0, 1.0>                 }                 rotate <0.0, 0.0, -10.0>                 translate <-0.3, 1.3, 0.0>         }         // Body         cone { <0.0, 0.1, 0.0>, 0.8, <0.0, 1.2, 0.0>, 0.3 }         // Foot         torus { 0.8, 0.1 translate <0.0, 0.1, 0.0> } }

Zur Kontrolle sollte man sich noch einmal alle Schachfiguren (pieces) anzeigen lassen, um beispielsweise visuell prüfen zu können, ob die Größen und Proportionen richtig gewählt wurden.

include "develop.pov" include "king.pov" include "queen.pov" include "bishop.pov" include "knight.pov" include "rook.pov" include "pawn.pov" union {         object { King }         object { Queen translate <3.0, 0.0, 0.0> }         object { Bishop translate <6.0, 0.0, 0.0> }         object { Knight translate <9.0, 0.0, 0.0> }         object { Rook translate <12.0, 0.0, 0.0> }         object { Pawn translate <15.0, 0.0, 0.0> }         translate <-7.5, 5.0, 0.0>         scale 0.24 }

Da nun die Deklarationen der einzelnen Figurentypen vorliegen, kann mit der Entwicklung verschiedener Schachszenen begonnen werden.

Eine Schachszene stellt hier das Schachbrett und die Möglichkeit, die Schachfiguren zu positionieren, zur Verfügung.

Die Umgebung einer Schachszene (chess.pov) setzt sich aus einem simplen Schachbrett und einer simplen Ebene, auf der das Schachbrett liegt, zusammen. Diese Umgebung implementiert zusätzlich Makros, mit denen Schachfiguren auf dem Schachbrett unter Angabe der Schachkoordinaten adäquat positioniert werden können (Workaround).

// Grauer Hintergrund background { color rgb <0.5, 0.5, 0.5> } // Kamera ein Stück nach oben und ein Stück nach hinten camera { location <0.0, 6.0, -8.0> look_at <0.0, 0.0, 0.0> } // Licht rechts oben und etwas nach hinten versetzt light_source { <6.0, 9.0, -7.0> color rgb <1.0, 1.0, 1.0> } // Das Schachbrett box {         <-4.0, 0.0, -4.0>, <4.0, -0.001, 4.0>         texture {                 pigment {                         checker                         color rgb <0.6, 0.6, 0.6>,                         color rgb <0.9, 0.9, 0.9>                 }                 finish {                         ambient 0.6                         reflection { 0.5 metallic }                 }         } } // Der Boden plane {         <0.0, 1.0, 0.0>, -0.001         texture {                 pigment { color rgb <0.3, 0.3, 0.3> }                 finish {                         diffuse 0.9                         ambient 0.4                         crand 0.05                         reflection { 0.9 metallic }                 }         } } // --------------------------------------------------------------- // Workaround für die Schachfiguren. // Textur der weißen Schachfiguren #declare WhiteTexture = texture {         pigment { color rgb <1.0, 0.95, 0.9> }         finish {                 diffuse 0.6                 ambient 0.28                 specular 0.2                 reflection { 0.2, 0.6 fresnel on }                 conserve_energy         } } // Textur der schwarzen Schachfiguren #declare BlackTexture = texture {         pigment { color rgb <0.6, 0.6, 0.6> }         finish {                 diffuse 0.6                 ambient 0.24                 specular 0.2                 reflection { 0.5 metallic }         } } // Positionierungsmakros für die Schachfiguren (Pieces) #macro SetPiece(Alpha, Num, Piece, Texture)         object {                 Piece                 scale 0.35                 texture { Texture }                 translate <Alpha - 4.5, 0.0, Num - 4.5>         } #end // Positionierungsmakro für weiße Schachfiguren #macro SetWhite(Alpha, Num, Piece)         SetPiece(Alpha, Num, Piece, WhiteTexture) #end // Positionierungsmakro für schwarze Schachfiguren #macro SetBlack(Alpha, Num, Piece)         SetPiece(Alpha, Num, Piece, BlackTexture) #end // Für mnemonische Koordinatenangaben #declare a = 1; #declare b = 2; #declare c = 3; #declare d = 4; #declare e = 5; #declare f = 6; #declare g = 7; #declare h = 8; // Schachfiguren bekannt machen // Wird chess.pov eingebunden, so werden automatisch auch // folgende Dateien, die die Schachfiguren deklarieren, eingebunden. include "king.pov" include "queen.pov" include "bishop.pov" include "knight.pov" include "rook.pov" include "pawn.pov"

Die verschiedenen Schachszenen lassen sich — wie Sie im Folgenden leicht erkennen können — dank der Umgebung extrem einfach entwickeln.
Die Grundaufstellung realisiert man nur noch mit den jeweiligen Positionsangaben aller schwarzen und weißen Schachfiguren.

include "chess.pov" // Grundaufstellung des Schachspiels. SetWhite(a, 1, Rook) SetWhite(b, 1, Knight) SetWhite(c, 1, Bishop) SetWhite(d, 1, Queen) SetWhite(e, 1, King) SetWhite(f, 1, Bishop) SetWhite(g, 1, Knight) SetWhite(h, 1, Rook) SetWhite(a, 2, Pawn) SetWhite(b, 2, Pawn) SetWhite(c, 2, Pawn) SetWhite(d, 2, Pawn) SetWhite(e, 2, Pawn) SetWhite(f, 2, Pawn) SetWhite(g, 2, Pawn) SetWhite(h, 2, Pawn) SetBlack(a, 7, Pawn) SetBlack(b, 7, Pawn) SetBlack(c, 7, Pawn) SetBlack(d, 7, Pawn) SetBlack(e, 7, Pawn) SetBlack(f, 7, Pawn) SetBlack(g, 7, Pawn) SetBlack(h, 7, Pawn) SetBlack(a, 8, Rook) SetBlack(b, 8, Knight) SetBlack(c, 8, Bishop) SetBlack(d, 8, Queen) SetBlack(e, 8, King) SetBlack(f, 8, Bishop) SetBlack(g, 8, Knight) SetBlack(h, 8, Rook)

Im Folgenden sehen Sie die Aufstellung für ein Matt in 2 Zügen von Weiß.

include "chess.pov" // Weiß setzt in 2 Zügen matt (Stickmatt). SetBlack(d, 8, Rook) SetBlack(g, 8, Knight) SetBlack(h, 8, King) SetBlack(g, 7, Pawn) SetBlack(h, 7, Pawn) SetBlack(f, 5, Queen) SetWhite(g, 5, Knight) SetWhite(h, 4, Queen) SetWhite(g, 2, King)

Und im Folgenden sehen Sie die Aufstellung für ein Matt in 3 Zügen von Weiß.

include "chess.pov" // Weiß setzt in 3 Zügen matt (Grundlienenmatt). SetBlack(d, 8, Rook) SetBlack(f, 8, King) SetBlack(f, 7, Pawn) SetBlack(g, 7, Pawn) SetBlack(h, 7, Pawn) SetBlack(d, 4, Queen) SetWhite(b, 3, Pawn) SetWhite(c, 2, Pawn) SetWhite(d, 2, Pawn) SetWhite(e, 2, Queen) SetWhite(c, 1, King) SetWhite(e, 1, Rook)

Es bleibt Ihrem Ehrgeiz überlassen, weitere Schachszenen mit diesem Framework zu erstellen.

Steckt man den Aufwand in die Umgebung, so entwickelt sich der Rest wie von allein. Hier lag der Aufwand in der Schachszenenumgebung (siehe chess.pov), mit der erst eine intuitive Szenenentwicklung unter Verwendung von Makros möglich wurde.
Sie dürfen mir gerne Verbesserungsvorschläge und Anregungen für diese Schachszenen an info@stefan−baur.de übermitteln. Bedenken Sie aber, dass ich diese Seite bewusst einfach gehalten habe. Aus diesem Grund bin ich besonders gewillt, Vereinfachungen einzubauen.

Vorliegendes POV−Ray−Framework für Schachszenen griffen Herr Dipl.−Inf. Detlef Rick (Mitarbeiter am Department Informatik der Uni Hamburg) und Frau Dipl.−Inf. Irina L. Marinescu (Informatiklehrerin an einer Hamburger Gesamtschule) im Frühjahr 2008 für ihren gemeinsamen Workshop

1. „Raytracing − Ein Einstieg in die Programmierung mit POV−Ray”

auf, was zu folgendem Ergebnis führte:

1. „Der Workshop war ein voller Erfolg! Die Schachaufgabe kam sehr gut an, da sie einen gewissen Anwendungsbezug herstellte, im Gegensatz zu anderen Aufgaben, bei denen es oft immer nur um irgendwelche Kugeln ging. Das Schöne war, dass wir eine gewisse Vorstellung davon vermitteln konnten, was mit POV-Ray möglich ist. Außerdem ist (..) [das] Framework so sauber aufgebaut, dass es als Vorbild dienen kann [...]” Detlef Rick.

Mein besonderer Dank gilt Herrn Dipl.−Inf. Detlef Rick und Frau Dipl.−Inf. Irina L. Marinescu. Sie haben freundlicherweise folgende Animation (obiges Stickmatt) in zwei unterschiedlichen Formaten der Öffentlichkeit zur Verfügung gestellt:

1. Stickmattanimation−MPG (1.413.120 Bytes)
2. Stickmattanimation−AVI (1.643.538 Bytes)

Ich wünsche weiterhin viel Erfolg mit POV−Ray.
Herzlichst
Stefan Karl Baur
PS: Mein Dank richtet sich auch an die engagierten Teilnehmer des Workshops.

+---+---+---+         | * | * | * |         +---+---+---+         | * | * | * | +---+---+---+---+---+---+---+ | * | * | * | * | * | * | * | +---+---+---+---+---+---+---+ | * | * | * |   | * | * | * | +---+---+---+---+---+---+---+ | * | * | * | * | * | * | * | +---+---+---+---+---+---+---+         | * | * | * |         +---+---+---+         | * | * | * |         +---+---+---+

Mehr ...