--- /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.fen;
+
+import java.util.regex.Pattern;
+
+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;
+
+/**
+ * Forsyth–Edwards Notation (FEN) parser.
+ *
+ * @author Dmitry Samoshin aka gotty
+ */
+public final class FENParser implements Parser {
+
+ private static final String SPLIT_REGEX = "\\s+";
+ private static final String LINE_REGEX = FEN.LINE_SEP;
+
+ private static final Pattern PATTERN =
+ Pattern.compile(
+ String.format("^(%s){%d} (%s) (%s) (%s) (%s) (%s)$",
+ FEN.Fields.PIECES.regex(), Square.getSize(),
+ FEN.Fields.MOVE.regex(),
+ FEN.Fields.CASTLE.regex(), FEN.Fields.EN_PASSANT.regex(),
+ FEN.Fields.HALFMOVE.regex(), FEN.Fields.FULLMOVE.regex()
+ )
+ );
+
+/*
+ private static final Pattern PATTERN =
+ Pattern.compile(
+ "^([pPnNbBrRqQkK1-8]+/?)* [wb] [qQkK]+|- ([a-h][36])|- [0-9]+ [1-9][0-9]*$"
+ );
+*/
+
+ private static Parser _instance = new FENParser();
+
+ private FENParser() {
+ }
+
+ public boolean isValidFen(String fen) {
+ return PATTERN.matcher(fen).matches();
+ }
+
+ @Override
+ public Position parse(String string) throws ParseException {
+ if (string == null)
+ throw new ParseException("parse.null.input.string");
+ if (!isValidFen(string))
+ throw new ParseException("parse.fen.invalid.string");
+
+ Position position = Positions.EMPTY.getPosition();
+
+ String[] fields = string.split(SPLIT_REGEX);
+
+ _parsePieces(
+ fields[FEN.Fields.PIECES.index()],
+ position
+ );
+ _parseMove(
+ fields[FEN.Fields.MOVE.index()],
+ position
+ );
+ _parseCastle(
+ fields[FEN.Fields.CASTLE.index()],
+ position
+ );
+ _parseEnPassant(
+ fields[FEN.Fields.EN_PASSANT.index()],
+ position
+ );
+ _parseHalfMove(
+ fields[FEN.Fields.HALFMOVE.index()],
+ position
+ );
+ _parseFullMove(
+ fields[FEN.Fields.FULLMOVE.index()],
+ position
+ );
+ return position;
+ }
+
+ private void _parsePieces(String fen, Position position) throws ParseException {
+ String[] lines = fen.split(LINE_REGEX);
+ if (lines.length != Square.getSize())
+ throw new ParseException("parse.fen.incorrect.board");
+ for (int i = 0; i < lines.length; ++i) {
+ int hLine = lines.length - (i + 1);
+ int vLine = 0;
+ char[] pieces = lines[i].toCharArray();
+ for (char piece : pieces) {
+ if (vLine >= Square.getSize())
+ throw new ParseException("parse.fen.incorrect.board");
+ if (Character.isDigit(piece)) {
+ int num = Character.getNumericValue(piece);
+ if (vLine + num > Square.getSize())
+ throw new ParseException("parse.fen.incorrect.board");
+ for (int j = 0; j < num; ++j) {
+ position.setPiece(
+ null,
+ Square.getSquare(vLine, hLine)
+ );
+ vLine++;
+ }
+ } else {
+ position.setPiece(
+ FEN.getColorPiece(piece),
+ Square.getSquare(vLine, hLine)
+ );
+ vLine++;
+ }
+ }
+ }
+ }
+
+ private void _parseMove(String move, Position position) {
+ position.setMove(
+ FEN.getColor(move.charAt(0))
+ );
+ }
+
+ private void _parseCastle(String castle, Position position) {
+ position.setCastle(
+ Color.WHITE,
+ FEN.getCastle(Color.WHITE, castle)
+ );
+ position.setCastle(
+ Color.BLACK,
+ FEN.getCastle(Color.BLACK, castle)
+ );
+ }
+
+ private void _parseEnPassant(String enPassant, Position position) {
+ position.setEnPassant(
+ FEN.getEnPassant(enPassant)
+ );
+ }
+
+ private void _parseHalfMove(String halfMove, Position position) {
+ position.setHalfMove(
+ Integer.parseInt(halfMove)
+ );
+ }
+
+ private void _parseFullMove(String fullMove, Position position) {
+ position.setFullMove(
+ Integer.parseInt(fullMove)
+ );
+ }
+
+ public static Parser getInstance() {
+ return _instance;
+ }
+
+ public static void main(String[] args) throws ParseException {
+
+/*
+ Pattern pattern =
+ Pattern.compile(
+ "^([pPnNbBrRqQkK1-8]+/?){8} [wb] ([qQkK]+|-) ([a-h][36]|-) [0-9]+ [1-9][0-9]*$"
+ );
+ System.out.println(
+ pattern.matcher("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - a6 0 1").matches()
+ );
+*/
+
+ Position position = getInstance().parse(
+ //"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+ "r7/7p/8/8/8/8/PPPPPP2/1N1Q2NR w KQkq a3 20 20"
+ );
+ System.out.println(position);
+ }
+
+}
git.hedgecode.org / chesshog.git / blobdiff