Startseite
Informatik
Algorithmen
Datenstrukturen
Software-Engineering
Programmiersprachen
Compiler
Interpreter
Java
C/C++
POV-Ray
POV-Ray-Koordinaten
DRUCK
2004
2005
2006
2007
2008
2009
POV-Ray-Schachspiel
POV-Ray-Zauberwürfel
LaTeX
Künstliche Intelligenz
Schach
Privates
Inhalt
POV-Ray-Schachspiel
Die Entstehung eines 3D-Schachspiels mit POV-Ray.
Die Entstehung eines 3D-Schachspiels mit POV-Ray.
Schachspiel
Schachspiel mit POV-Ray
Vorliegende Seite demonstriert die Entwicklung eines dreidimensionalen Schachspiels mit Povray.
Grundaufstellung des 3D-Schachs
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!
Entwicklungsdauer
Die Entwicklung dieses
3D-Bildes
hat nur einen Tag in Anspruch genommen.
Das Publizieren der vorliegenden Seite hingegen dauerte deutlich länger.
:-(
Schachfiguren
Simple 3D-Schachfiguren
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).
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).
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
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.
pawn.pov
#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.
develop.pawn.pov
include "develop.pov"
include "pawn.pov"
Pawn
Der König
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).
king.pov
#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
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.
queen.pov
#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> }
}
Der Läufer
Ü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.
bishop.pov
#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> }
}
Der Turm
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.
rook.pov
#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> }
}
Der Springer
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.
knight.pov
#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.
develop.pieces.pov
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.
Schachszenen
Simple 3D-Schachszenen
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).
chess.pov
// 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.
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.
Anmerkung
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.
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.
Animation
Animiertes Schachspiel bzw. Mattspiel
Erfolgreicher Workshop
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
Herzlichst
Stefan Karl Baur
PS: Mein Dank richtet sich auch an die engagierten Teilnehmer des Workshops.
- „Raytracing - Ein Einstieg in die Programmierung mit POV-Ray”
- „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.
Herzlichst
Stefan Karl Baur
PS: Mein Dank richtet sich auch an die engagierten Teilnehmer des Workshops.