src/algebraicnotation.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #include <iostream>
  12 #include <QRegExp>
  13 #include "algebraicnotation.h"
  14 #include "variants/xchess/piece.h"
  15 #include "variants/xchess/move.h"
  16
  17 //BEGIN AlgebraicNotation
  18
  19 //                                        1           2                   3
  20 QRegExp AlgebraicNotation::pattern("^([PRNBKQ])?([a-wyzA-Z]?\\d*|x\\d+)([-x@])?"
  21 //                                       4         5        6
  22                                    "([a-zA-Z]\\d+)(=?([RNBKQrnbkq]))?[+#]?[\?!]*");
  23 QRegExp AlgebraicNotation::kingCastlingPattern("^[oO0]-?[oO0][+#]?");
  24 QRegExp AlgebraicNotation::queenCastlingPattern("^[oO0]-?[oO0]-?[oO0][+#]?");
  25 QRegExp AlgebraicNotation::nonePattern("^none");
  26
  27 AlgebraicNotation::AlgebraicNotation()
  28 : from(Point::invalid())
  29 , to(Point::invalid())
  30 , type(-1)
  31 , promotion(-1)
  32 , castling(NoCastling)
  33 , drop(false) {
  34 }
  35
  36 AlgebraicNotation::AlgebraicNotation(const QString& str, int ysize)
  37 : from(Point::invalid())
  38 , to(Point::invalid())
  39 , type(-1)
  40 , promotion(-1)
  41 , castling(NoCastling)
  42 , drop(false) {
  43
  44   int offset = 0;
  45   init(str, offset, ysize);
  46 }
  47
  48 AlgebraicNotation::AlgebraicNotation(const QString& str, int& offset, int ysize)
  49 : from(Point::invalid())
  50 , to(Point::invalid())
  51 , type(-1)
  52 , promotion(-1)
  53 , castling(NoCastling)
  54 , drop(false) {
  55
  56   init(str, offset, ysize);
  57 }
  58
  59 void AlgebraicNotation::init(const QString& str, int& offset, int ysize) {
  60   if (nonePattern.indexIn(str, offset, QRegExp::CaretAtOffset) != -1) {
  61     from = Point::invalid();
  62     to = Point::invalid();
  63     offset += nonePattern.matchedLength();
  64   }
  65   else if (pattern.indexIn(str, offset, QRegExp::CaretAtOffset) != -1) {
  66     type = ChessPiece::getType(pattern.cap(1));
  67     drop = pattern.cap(3) == "@";
  68     if (drop)
  69       from = Point::invalid();
  70     else
  71       from = Point(pattern.cap(2), ysize);
  72     to = Point(pattern.cap(4), ysize);
  73     promotion = pattern.cap(6).isEmpty() ? -1 : ChessPiece::getType(pattern.cap(6));
  74     castling = NoCastling;
  75     offset += pattern.matchedLength();
  76   }
  77   else if (queenCastlingPattern.indexIn(str, offset, QRegExp::CaretAtOffset) != -1) {
  78     castling = QueenSide;
  79
  80     offset += queenCastlingPattern.matchedLength();
  81   }
  82   else if (kingCastlingPattern.indexIn(str, offset, QRegExp::CaretAtOffset) != -1) {
  83     castling = KingSide;
  84
  85     offset += kingCastlingPattern.matchedLength();
  86   }
  87   else {
  88     //std::cout << "error!!!! " << str.mid(offset) << std::endl;
  89     to = Point::invalid();
  90   }
  91 }
  92
  93 std::ostream& operator<<(std::ostream& os, const AlgebraicNotation& move) {
  94   if (move.castling == AlgebraicNotation::KingSide)
  95     return os << "O-O";
  96   else if (move.castling == AlgebraicNotation::QueenSide)
  97     return os << "O-O-O";
  98   else
  99     return os << move.type << ": " << move.from << " -> " << move.to;
 100 }
 101
 102 //END AlgebraicNotation
 103
 104
 105 //BEGIN VerboseNotation
 106 //                                     1          2           3            5
 107 QRegExp VerboseNotation::pattern("([PRNBKQ])/([a-zA-Z]\\d+|@@)-([a-zA-Z]\\d+)(=([PRNBKQ]))?");
 108 QRegExp VerboseNotation::kingCastlingPattern("[oO0]-[oO0]");
 109 QRegExp VerboseNotation::queenCastlingPattern("[oO0]-[oO0]-[oO0]");
 110 QRegExp VerboseNotation::nonePattern("none");
 111
 112 VerboseNotation::VerboseNotation(const QString& str, int ysize)
 113 : promotion(INVALID_TYPE) {
 114   if (nonePattern.indexIn(str) == 0) {
 115     from = Point::invalid();
 116     to = Point::invalid();
 117   }
 118   else if (pattern.indexIn(str) == 0) {
 119     if (pattern.cap(2) == "@@")
 120       from = Point::invalid();
 121     else
 122       from = Point(pattern.cap(2), ysize);
 123
 124     to = Point(pattern.cap(3), ysize);
 125
 126     type = ChessPiece::getType(pattern.cap(1));
 127     if (!pattern.cap(5).isEmpty())
 128       promotion = ChessPiece::getType(pattern.cap(6));
 129     else
 130       promotion = INVALID_TYPE;
 131     castling = AlgebraicNotation::NoCastling;
 132   }
 133   else if (queenCastlingPattern.indexIn(str) == 0)
 134     castling = AlgebraicNotation::QueenSide;
 135   else if (kingCastlingPattern.indexIn(str) == 0)
 136     castling = AlgebraicNotation::KingSide;
 137   else {
 138     from = Point::invalid();
 139     to = Point::invalid();
 140     castling = AlgebraicNotation::NoCastling;
 141   }
 142 }
 143
 144 //END VerboseNotation