diff -r 41bbfd4d17a3 -r 824c9522ce66 src/chess/rules.c
--- a/src/chess/rules.c	Mon Mar 31 14:08:00 2014 +0200
+++ b/src/chess/rules.c	Mon Mar 31 15:03:25 2014 +0200
@@ -30,6 +30,30 @@
 #include "rules.h"
 #include "chess.h"
 #include <string.h>
+#include <stdlib.h>
+
+void gamestate_cleanup(GameState *gamestate) {
+    MoveList *elem;
+    elem = gamestate->movelist;
+    while (elem) {
+        MoveList *cur = elem;
+        elem = elem->next;
+        free(cur);
+    };
+}
+
+static void addmove(GameState* gamestate, Move *move) {
+    MoveList *elem = malloc(sizeof(MoveList));
+    elem->next = NULL;
+    elem->move = *move;
+    
+    if (gamestate->lastmove) {
+        gamestate->lastmove->next = elem;
+        gamestate->lastmove = elem;
+    } else {
+        gamestate->movelist = gamestate->lastmove = elem;
+    }
+}
 
 char getpiecechr(uint8_t piece) {
     switch (piece & PIECE_MASK) {
@@ -53,41 +77,34 @@
     }
 }
 
-/**
- * Guesses the location of a piece for short algebraic notation.
- * 
- * @param board the current state of the board
- * @param move the move date to operate on
- * @return status code (see rules/rules.h for the codes)
- */
-static int getlocation(Board board, Move *move) {   
+static int getlocation(GameState *gamestate, Move *move) {   
     uint8_t piece = move->piece & PIECE_MASK;
     switch (piece) {
-        case PAWN: return pawn_getlocation(board, move);
-        case ROOK: return rook_getlocation(board, move);
-        case KNIGHT: return knight_getlocation(board, move);
-        case BISHOP: return bishop_getlocation(board, move);
-        case QUEEN: return queen_getlocation(board, move);
-        case KING: return king_getlocation(board, move);
+        case PAWN: return pawn_getlocation(gamestate, move);
+        case ROOK: return rook_getlocation(gamestate, move);
+        case KNIGHT: return knight_getlocation(gamestate, move);
+        case BISHOP: return bishop_getlocation(gamestate, move);
+        case QUEEN: return queen_getlocation(gamestate, move);
+        case KING: return king_getlocation(gamestate, move);
         default: return INVALID_MOVE_SYNTAX;
     }
 }
 
 
-void apply_move(Board board, Move *move) {
+void apply_move(GameState *gamestate, Move *move) {
     uint8_t piece = move->piece & PIECE_MASK;
     uint8_t color = move->piece & COLOR_MASK;
     
     /* en passant capture */
     if (move->capture && piece == PAWN &&
-        mdst(board, move) == 0) {
-        board[move->fromrow][move->tofile] = 0;
+        mdst(gamestate->board, move) == 0) {
+        gamestate->board[move->fromrow][move->tofile] = 0;
     }
     
     /* remove old en passant threats */
     for (uint8_t file = 0 ; file < 8 ; file++) {
-        board[3][file] &= ~ENPASSANT_THREAT;
-        board[4][file] &= ~ENPASSANT_THREAT;
+        gamestate->board[3][file] &= ~ENPASSANT_THREAT;
+        gamestate->board[4][file] &= ~ENPASSANT_THREAT;
     }
     
     /* add new en passant threat */
@@ -98,11 +115,11 @@
     }
     
     /* move (and maybe capture or promote) */
-    msrc(board, move) = 0;
+    msrc(gamestate->board, move) = 0;
     if (move->promotion) {
-        mdst(board, move) = move->promotion;
+        mdst(gamestate->board, move) = move->promotion;
     } else {
-        mdst(board, move) = move->piece;
+        mdst(gamestate->board, move) = move->piece;
     }
     
     /* castling */
@@ -110,16 +127,18 @@
         move->fromfile == fileidx('e')) {
         
         if (move->tofile == fileidx('g')) {
-            board[move->torow][fileidx('h')] = 0;
-            board[move->torow][fileidx('f')] = color|ROOK;
+            gamestate->board[move->torow][fileidx('h')] = 0;
+            gamestate->board[move->torow][fileidx('f')] = color|ROOK;
         } else if (move->tofile == fileidx('c')) {
-            board[move->torow][fileidx('a')] = 0;
-            board[move->torow][fileidx('d')] = color|ROOK;
+            gamestate->board[move->torow][fileidx('a')] = 0;
+            gamestate->board[move->torow][fileidx('d')] = color|ROOK;
         }
     }
+    
+    addmove(gamestate, move);
 }
 
-_Bool validate_move(Board board, Move *move) {
+_Bool validate_move(GameState *gamestate, Move *move) {
     _Bool result;
     
     /* validate indices (don't trust opponent) */
@@ -133,38 +152,39 @@
     }
     
     /* does piece exist */
-    result = msrc(board, move) == move->piece;
+    result = msrc(gamestate->board, move) == move->piece;
     
     /* can't capture own pieces */
-    if ((mdst(board, move) & COLOR_MASK) == (move->piece & COLOR_MASK)) {
+    if ((mdst(gamestate->board, move) & COLOR_MASK)
+        == (move->piece & COLOR_MASK)) {
         return 0;
     }
     
     /* validate individual rules */
     switch (move->piece & PIECE_MASK) {
     case PAWN:
-        result = result && pawn_chkrules(board, move);
-        result = result && !pawn_isblocked(board, move);
+        result = result && pawn_chkrules(gamestate, move);
+        result = result && !pawn_isblocked(gamestate, move);
         break;
     case ROOK:
         result = result && rook_chkrules(move);
-        result = result && !rook_isblocked(board, move);
+        result = result && !rook_isblocked(gamestate, move);
         break;
     case KNIGHT:
         result = result && knight_chkrules(move);
-        result = result && !knight_isblocked(board, move);
+        result = result && !knight_isblocked(gamestate, move);
         break;
     case BISHOP:
         result = result && bishop_chkrules(move);
-        result = result && !bishop_isblocked(board, move);
+        result = result && !bishop_isblocked(gamestate, move);
         break;
     case QUEEN:
         result = result && queen_chkrules(move);
-        result = result && !queen_isblocked(board, move);
+        result = result && !queen_isblocked(gamestate, move);
         break;
     case KING:
-        result = result && king_chkrules(board, move);
-        result = result && !king_isblocked(board, move);
+        result = result && king_chkrules(gamestate, move);
+        result = result && !king_isblocked(gamestate, move);
         break;
     default:
         result = 0;
@@ -179,7 +199,7 @@
     return result;
 }
 
-int eval_move(Board board, uint8_t mycolor, char *mstr, Move *move) {
+int eval_move(GameState *gamestate, char *mstr, Move *move) {
     memset(move, 0, sizeof(Move));
     move->fromfile = POS_UNSPECIFIED;
     move->fromrow = POS_UNSPECIFIED;
@@ -201,7 +221,7 @@
         if (!move->promotion) {
             return INVALID_MOVE_SYNTAX;
         } else {
-            move->promotion |= mycolor;
+            move->promotion |= gamestate->mycolor;
             len -= 2;
             mstr[len] = 0;
         }
@@ -218,7 +238,7 @@
             move->piece = KING;
             move->fromfile = fileidx('e');
             move->tofile = fileidx('g');
-            move->fromrow = move->torow = mycolor == WHITE ? 0 : 7;
+            move->fromrow = move->torow = gamestate->mycolor == WHITE ? 0 : 7;
         } else {
             /* move (e.g. "Nf3") */
             move->piece = getpiece(mstr[0]);
@@ -254,7 +274,7 @@
             move->piece = KING;
             move->fromfile = fileidx('e');
             move->tofile = fileidx('c');
-            move->fromrow = move->torow = mycolor == WHITE ? 0 : 7;
+            move->fromrow = move->torow = gamestate->mycolor == WHITE ? 0 : 7;
         } else {
             move->piece = getpiece(mstr[0]);
             if (mstr[2] == 'x') {
@@ -290,15 +310,16 @@
 
     
     if (move->piece) {
-        if (move->piece == PAWN && move->torow == (mycolor==WHITE?7:0)
+        if (move->piece == PAWN
+            && move->torow == (gamestate->mycolor==WHITE?7:0)
             && !move->promotion) {
             return NEED_PROMOTION;
         }
         
-        move->piece |= mycolor;
+        move->piece |= gamestate->mycolor;
         if (move->fromfile == POS_UNSPECIFIED
             || move->fromrow == POS_UNSPECIFIED) {
-            return getlocation(board, move);
+            return getlocation(gamestate, move);
         } else {
             return chkidx(move) ? VALID_MOVE_SYNTAX : INVALID_POSITION;
         }