--- a/doodle/dia/layer_stack.d	Tue Dec 13 19:18:25 2011 +1030
+++ b/doodle/dia/layer_stack.d	Thu Jan 12 16:42:16 2012 +1030
@@ -5,7 +5,7 @@
 }
 
 final class LayerStack {
-    this(in Layer[] layers) {
+    this(Layer[] layers) {
         _layers = layers.dup;
     }
 

--- a/doodle/dia/tool_layer.d	Tue Dec 13 19:18:25 2011 +1030
+++ b/doodle/dia/tool_layer.d	Thu Jan 12 16:42:16 2012 +1030
@@ -18,7 +18,7 @@
 }
 
 final class ToolLayer : Layer, IEventHandler, IToolStack {
-    this(in Tool[] staticTools, IToolStackObserver observer, in string name = "Tool") {
+    this(Tool[] staticTools, IToolStackObserver observer, in string name = "Tool") {
         super(name);
         _staticTools = staticTools.dup;
         _observer = observer;

--- a/doodle/gtk/cairo_canvas.d	Tue Dec 13 19:18:25 2011 +1030
+++ b/doodle/gtk/cairo_canvas.d	Thu Jan 12 16:42:16 2012 +1030
@@ -45,7 +45,7 @@
             ];
     }
 
-    this(in Layer[] layers, IEventHandler eventHandler, IGrid grid, in double pixelsPerMillimetre) {
+    this(Layer[] layers, IEventHandler eventHandler, IGrid grid, in double pixelsPerMillimetre) {
         super(3, 3, 0);
 
         _eventHandler = eventHandler;

--- a/doodle/main/prog/chess.d	Tue Dec 13 19:18:25 2011 +1030
+++ b/doodle/main/prog/chess.d	Thu Jan 12 16:42:16 2012 +1030
@@ -1,26 +1,33 @@
 import std.stdio;
+import std.ascii;
 import std.traits;
 import std.range;
 
-enum Color {
+enum Color {                // (side/player?)
     White, Black
 }
 
 Color invert(Color c) {
-    return c == Color.White ? Color.Black : Color.White;
+    return [Color.Black, Color.White][c];
 }
 
 enum Piece {
     King, Queen, Rook, Bishop, Knight, Pawn
 }
 
+/*
+enum Shade {                // (color?)
+    Light, Dark
+}
+*/
+
 string toString(Color color, Piece piece) {
-    string[6][2] table =
+    return
         [
         [ "\u2654", "\u2655", "\u2656", "\u2657", "\u2658", "\u2659" ],
         [ "\u265A", "\u265B", "\u265C", "\u265D", "\u265E", "\u265F" ]
-        ];
-    return table[color][piece];
+        ]
+        [color][piece];
 }
 
 struct Square {
@@ -40,8 +47,7 @@
 }
 
 char toChar(File f) {
-    char[8] table = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' ];
-    return table[f];
+    return "abcdefgh"[f];
 }
 
 enum Rank {
@@ -49,8 +55,7 @@
 }
 
 char toChar(Rank r) {
-    char[8] table = [ '1', '2', '3', '4', '5', '6', '7', '8' ];
-    return table[r];
+    return "12345678"[r];
 }
 
 struct Coord {
@@ -58,34 +63,50 @@
     Rank rank;
 }
 
-struct Move {
+struct Update {
     Coord source;
     Coord dest;
 }
 
 struct Board {
-    this(Board board, Move move) {
+    this(Board board, Update update) {
         squares = board.squares;
-        apply(move);
+        apply(update);
     }
 
     Square square(Coord coord) const {
         return squares[coord.file][coord.rank];
     }
 
+    struct SideState {
+        struct PieceState {
+            bool  captured;
+            Coord location;
+        };
+
+        PieceState[16] pieceStates;
+
+        @property bool canQueenSideCastle() { return !kingMoved && !queenRookMoved; }
+        @property bool canKingSideCastle()  { return !kingMoved && !kingRookMoved;  }
+
+        bool kingMoved;
+        bool queenRookMoved;
+        bool kingRookMoved;
+    }
+
 private:
     Square * square(Coord coord) {
         return &squares[coord.file][coord.rank];
     }
 
-    void apply(Move move) {
-        auto sq1 = square(move.source);
-        auto sq2 = square(move.dest);
+    void apply(Update update) {
+        auto sq1 = square(update.source);
+        auto sq2 = square(update.dest);
 
-        if (sq1.piece == Piece.Pawn && move.dest.file != move.source.file) {
+        if (sq1.piece == Piece.Pawn && update.dest.file != update.source.file) {
             // en-passant
         }
-        else if (sq1.piece == Piece.King && move.dest.file - move.source.file > 1) {
+        else if (sq1.piece == Piece.King && update.dest.file - update.source.file > 1) {
             // castle
         }
         else {
@@ -143,7 +164,65 @@
     writeln("");
 }
 
+struct Move {
+}
+
+class Player {
+    abstract Move getMove(in Board board);
+}
+
+class Game {
+    @property Board board() { return _board; }
+
+    this (Player white, Player black) {
+        Color turn = Color.White;
+
+        for (;;) {
+            bool valid = false;
+
+            _players[turn].getMove(_board);
+            // TODO apply 
+            valid = true;
+
+            if (valid) {
+                turn = invert(turn);
+            }
+        }
+    }
+
+    private {
+        Player[2] _players;
+        Board     _board;
+    }
+}
+
+class HumanPlayer : Player {
+    //immutable Piece[char] _pieceByChar = [ 'A' : Piece.Queen ];
+    //auto a = [ 1 : 2 ];
+
+    override Move getMove(in Board board) {
+        /*
+        for (;;) {
+            char[] buf;
+            readln(buf);
+
+            Piece piece = Piece.Pawn;
+
+            if (buf.length >= 2) {
+                if (isUpper(buf[0])) {
+                }
+            }
+        }
+        */
+
+        return Move();
+    }
+}
+
 void main(string[] args) {
     Board board;
     dump(board);
+
+    Game game;
+
 }