--- /dev/null
+/*
+ * Copyright (c) 2018. Developed by Hedgecode.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.hedgecode.chess.tcd;
+
+import org.hedgecode.chess.position.Castle;
+import org.hedgecode.chess.position.Color;
+import org.hedgecode.chess.position.ParseException;
+import org.hedgecode.chess.position.Parser;
+import org.hedgecode.chess.position.Position;
+import org.hedgecode.chess.position.Positions;
+import org.hedgecode.chess.position.Square;
+
+/**
+ * Tiny Chess Diagram (TCD) parser.
+ *
+ * @author Dmitry Samoshin aka gotty
+ */
+public final class TCDParser implements Parser {
+
+ private static Parser _instance = new TCDParser();
+
+ private TCDParser() {
+ }
+
+ private final class TCDIterator {
+
+ private byte[] bytes;
+ private int pos;
+ private boolean isHighPart;
+
+ TCDIterator(byte[] bytes) {
+ this.bytes = bytes;
+ this.pos = 0;
+ this.isHighPart = true;
+ }
+
+ boolean hasNext() {
+ return (bytes.length > pos + 1) || (isHighPart && bytes.length > pos);
+ }
+
+ boolean isLast() {
+ return !isHighPart && (bytes.length - 1 == pos);
+ }
+
+ byte next() throws ParseException {
+ isHighPart = !isHighPart;
+ if (isHighPart)
+ pos++;
+ return current();
+ }
+
+ byte current() throws ParseException {
+ if (bytes.length <= pos)
+ throw new ParseException("parse.tcd.index.out.of.bounds");
+ byte frame = bytes[pos];
+ if (isHighPart)
+ frame = (byte) (frame >> TCD.FRAME_LENGTH);
+ return (byte) (frame & TCD.FRAME_MASK);
+ }
+ }
+
+ @Override
+ public Position parse(String string) throws ParseException {
+ return parse(
+ string.getBytes()
+ );
+ }
+
+ public Position parse(byte[] bytes) throws ParseException {
+ TCD.replaceFrom(bytes);
+ if (!TCD.isValid(bytes))
+ throw new ParseException("parse.tcd.invalid.bytes");
+ TCDIterator iterator = new TCDIterator(bytes);
+ return _parse(iterator);
+ }
+
+ private Position _parse(TCDIterator iterator) throws ParseException {
+ Position position;
+
+ byte curr = iterator.current();
+ byte next = iterator.next();
+
+ if (TCD.isBlackWhite(curr, next)) {
+ position = Positions.INITIAL.getPosition();
+ curr = iterator.next();
+ next = iterator.next();
+ } else {
+ position = Positions.EMPTY.getPosition();
+ boolean isWhiteAssigned = false, isBlackAssigned = false;
+ while (!isWhiteAssigned || !isBlackAssigned) {
+ switch (curr) {
+ case TCD.WHITE:
+ _parsePieces(Color.WHITE, position, iterator);
+ isWhiteAssigned = true;
+ break;
+ case TCD.BLACK:
+ _parsePieces(Color.BLACK, position, iterator);
+ isBlackAssigned = true;
+ break;
+ default:
+ throw new ParseException("parse.tcd.incorrect.color");
+ }
+ curr = iterator.current();
+ next = iterator.next();
+ }
+ }
+
+ if (!TCD.isWhiteBlack(curr, next))
+ throw new ParseException("parse.tcd.incorrect.end");
+
+ _parseAddition(position, iterator);
+
+ return position;
+ }
+
+ private void _parsePieces(Color color, Position position, TCDIterator iterator) throws ParseException {
+ byte piece = iterator.current();
+ while (TCD.isNotColor(piece)) {
+ int pieceCount = iterator.next() + 1;
+ for (int i = 0; i < pieceCount; ++i) {
+ Square square = _parseSquare(iterator);
+ switch (piece) {
+ case TCD.PAWN:
+ position.setPawn(color, square);
+ break;
+ case TCD.KNIGHT:
+ position.setKnight(color, square);
+ break;
+ case TCD.BISHOP:
+ position.setBishop(color, square);
+ break;
+ case TCD.ROOK:
+ position.setRook(color, square);
+ break;
+ case TCD.QUEEN:
+ position.setQueen(color, square);
+ break;
+ case TCD.KING:
+ position.setKing(color, square);
+ break;
+ default:
+ throw new ParseException("parse.tcd.incorrect.piece");
+ }
+ }
+ piece = iterator.next();
+ }
+ }
+
+ private void _parseAddition(Position position, TCDIterator iterator) throws ParseException {
+ if (iterator.hasNext()) {
+ byte frame = iterator.next();
+ if (iterator.isLast() && frame != TCD.END) {
+ throw new ParseException("parse.tcd.incorrect.end");
+ } else {
+ boolean isEndPosition = false;
+ while (!isEndPosition) {
+ switch (frame) {
+ case TCD.MOVE:
+ position.setMove(
+ _parseMove(iterator)
+ );
+ break;
+ case TCD.CASTLE_WHITE:
+ position.setCastle(
+ Color.WHITE, _parseCastle(iterator)
+ );
+ break;
+ case TCD.CASTLE_BLACK:
+ position.setCastle(
+ Color.BLACK, _parseCastle(iterator)
+ );
+ break;
+ case TCD.EN_PASSANT:
+ position.setEnPassant(
+ _parseSquare(iterator)
+ );
+ break;
+ case TCD.HALFMOVE:
+ position.setHalfMove(
+ _parseNumber(iterator)
+ );
+ break;
+ case TCD.FULLMOVE:
+ position.setFullMove(
+ _parseNumber(iterator)
+ );
+ break;
+ default:
+ throw new ParseException("parse.tcd.incorrect.addition");
+ }
+ isEndPosition = true;
+ if (iterator.hasNext()) {
+ frame = iterator.next();
+ if (iterator.isLast() && frame != TCD.END) {
+ throw new ParseException("parse.tcd.incorrect.end");
+ }
+ isEndPosition = iterator.isLast();
+ }
+ }
+ }
+ }
+ }
+
+ private Square _parseSquare(TCDIterator iterator) throws ParseException {
+ byte vl = iterator.next();
+ byte hl = iterator.next();
+ return Square.getSquare(vl, hl);
+ }
+
+ private Color _parseMove(TCDIterator iterator) throws ParseException {
+ byte frame = iterator.next();
+ if (TCD.isNotColor(frame))
+ throw new ParseException("parse.tcd.incorrect.move.color");
+ return frame == TCD.WHITE ? Color.WHITE : Color.BLACK;
+ }
+
+ private Castle _parseCastle(TCDIterator iterator) throws ParseException {
+ byte frame = iterator.next();
+ if (TCD.isNotCastle(frame))
+ throw new ParseException("parse.tcd.incorrect.castle");
+ Castle castle = Castle.NONE;
+ switch (frame) {
+ case TCD.CASTLE_KING:
+ castle = Castle.KING;
+ break;
+ case TCD.CASTLE_QUEEN:
+ castle = Castle.QUEEN;
+ break;
+ case TCD.CASTLE_BOTH:
+ castle = Castle.BOTH;
+ break;
+ }
+ return castle;
+ }
+
+ private int _parseNumber(TCDIterator iterator) throws ParseException {
+ return iterator.next() << (2 * TCD.FRAME_LENGTH)
+ | iterator.next() << TCD.FRAME_LENGTH
+ | iterator.next();
+ }
+
+ public static Parser getInstance() {
+ return _instance;
+ }
+
+
+ public static void main(String[] args) throws ParseException {
+ //Position position = getInstance().parse("A7ONMILHJJIFCJEDO0ECFD0OvFV+4fnNQwOYoWaG-h5pgG");
+ //Position position = getInstance().parse("xG");
+ Position position = getInstance().parse("A7ONMILHJJIFCJEDO0ECFDGOvFV+4fnNQwOYoWaG-h5pgG");
+ System.out.println(position);
+ }
+
+}
git.hedgecode.org / chesshog.git / blobdiff