--- /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;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.hedgecode.chess.position.Color;
+import org.hedgecode.chess.position.ColorPiece;
+import org.hedgecode.chess.position.Piece;
+import org.hedgecode.chess.position.Position;
+import org.hedgecode.chess.position.Positions;
+import org.hedgecode.chess.position.Square;
+import org.hedgecode.chess.position.SquareSort;
+
+/**
+ *
+ *
+ * @author Dmitry Samoshin aka gotty
+ */
+public final class EtudeUtils {
+
+ private static final byte PIECE_MASK = 0b1111;
+ private static final byte PIECE_LENGTH = 4;
+
+ private static final byte NUM_WHITE_PAWN = 0;
+ private static final byte NUM_WHITE_KNIGHT = 1;
+ private static final byte NUM_WHITE_BISHOP = 2;
+ private static final byte NUM_WHITE_ROOK = 3;
+ private static final byte NUM_WHITE_QUEEN = 4;
+
+ private static final byte NUM_BLACK_PAWN = 5;
+ private static final byte NUM_BLACK_KNIGHT = 6;
+ private static final byte NUM_BLACK_BISHOP = 7;
+ private static final byte NUM_BLACK_ROOK = 8;
+ private static final byte NUM_BLACK_QUEEN = 9;
+
+ private static final byte BLOB_PIECE_EMPTY = 0b0000;
+
+ private static final byte BLOB_WHITE_PAWN = 0b0001;
+ private static final byte BLOB_WHITE_KNIGHT = 0b0010;
+ private static final byte BLOB_WHITE_BISHOP = 0b0011;
+ private static final byte BLOB_WHITE_ROOK = 0b0100;
+ private static final byte BLOB_WHITE_QUEEN = 0b0101;
+ private static final byte BLOB_WHITE_KING = 0b0110;
+
+ private static final byte BLOB_BLACK_PAWN = 0b1001;
+ private static final byte BLOB_BLACK_KNIGHT = 0b1010;
+ private static final byte BLOB_BLACK_BISHOP = 0b1011;
+ private static final byte BLOB_BLACK_ROOK = 0b1100;
+ private static final byte BLOB_BLACK_QUEEN = 0b1101;
+ private static final byte BLOB_BLACK_KING = 0b1110;
+
+ private static final Map<ColorPiece, Byte> PIECE_NUMBERS = new HashMap<ColorPiece, Byte>() {
+ {
+ put(ColorPiece.WHITE_PAWN, NUM_WHITE_PAWN); put(ColorPiece.BLACK_PAWN, NUM_BLACK_PAWN);
+ put(ColorPiece.WHITE_KNIGHT, NUM_WHITE_KNIGHT); put(ColorPiece.BLACK_KNIGHT, NUM_BLACK_KNIGHT);
+ put(ColorPiece.WHITE_BISHOP, NUM_WHITE_BISHOP); put(ColorPiece.BLACK_BISHOP, NUM_BLACK_BISHOP);
+ put(ColorPiece.WHITE_ROOK, NUM_WHITE_ROOK); put(ColorPiece.BLACK_ROOK, NUM_BLACK_ROOK);
+ put(ColorPiece.WHITE_QUEEN, NUM_WHITE_QUEEN); put(ColorPiece.BLACK_QUEEN, NUM_BLACK_QUEEN);
+ }
+ };
+
+ private static final Map<ColorPiece, Byte> BLOB_PIECES = new HashMap<ColorPiece, Byte>() {
+ {
+ put(ColorPiece.WHITE_PAWN, BLOB_WHITE_PAWN); put(ColorPiece.BLACK_PAWN, BLOB_BLACK_PAWN);
+ put(ColorPiece.WHITE_KNIGHT, BLOB_WHITE_KNIGHT); put(ColorPiece.BLACK_KNIGHT, BLOB_BLACK_KNIGHT);
+ put(ColorPiece.WHITE_BISHOP, BLOB_WHITE_BISHOP); put(ColorPiece.BLACK_BISHOP, BLOB_BLACK_BISHOP);
+ put(ColorPiece.WHITE_ROOK, BLOB_WHITE_ROOK); put(ColorPiece.BLACK_ROOK, BLOB_BLACK_ROOK);
+ put(ColorPiece.WHITE_QUEEN, BLOB_WHITE_QUEEN); put(ColorPiece.BLACK_QUEEN, BLOB_BLACK_QUEEN);
+ put(ColorPiece.WHITE_KING, BLOB_WHITE_KING); put(ColorPiece.BLACK_KING, BLOB_BLACK_KING);
+ }
+ };
+
+ public static BigInteger hashPosition(Position position) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(
+ numSquare(
+ kingSquare(Color.WHITE, position)
+ )
+ ).append(
+ numSquare(
+ kingSquare(Color.BLACK, position)
+ )
+ );
+ int empty = 0;
+ for (Map.Entry<Square, ColorPiece> entry : position.getSquares(SquareSort.A8H1).entrySet()) {
+ ColorPiece colorPiece = entry.getValue();
+ if (colorPiece != null && !Piece.KING.equals(colorPiece.piece())) {
+ if (empty > 0)
+ sb.append(empty);
+ sb.append(
+ PIECE_NUMBERS.get(colorPiece)
+ );
+ empty = 0;
+ } else {
+ ++empty;
+ }
+ }
+ if (empty > 0)
+ sb.append(empty);
+
+ return new BigInteger(
+ sb.toString() /* todo: SQL: NUMERIC(64,0) */
+ );
+ }
+
+ public static byte[] blobPosition(Position position) {
+ byte[] blob = new byte[Square.getSize() * Square.getSize()];
+ int i = 0;
+ for (Map.Entry<Square, ColorPiece> entry : position.getSquares(SquareSort.A8H1).entrySet()) {
+ ColorPiece colorPiece = entry.getValue();
+ blob[i++] = colorPiece != null ? BLOB_PIECES.get(colorPiece) : BLOB_PIECE_EMPTY;
+ }
+ return compress(blob);
+ }
+
+ private static Square kingSquare(Color color, Position position) {
+ Square kingSquare = null;
+
+ Map<Square, ColorPiece> king = position.getSquarePieces(color, Piece.KING);
+
+ if (king.isEmpty() || king.size() > 1)
+ throw new RuntimeException("Incorrect position"); // todo
+
+ for (Square square : king.keySet()) {
+ kingSquare = square;
+ }
+ return kingSquare;
+ }
+
+ private static int numSquare(Square square) {
+ int v = square.getV() + 1;
+ int h = Square.getSize() - square.getH();
+ return Square.getSize() * (h - 1) + v;
+ }
+
+ private static byte[] compress(byte[] bytes) {
+ byte[] cmpBytes = new byte[bytes.length / 2];
+ byte high, low;
+ int i = 0;
+ for (int j = 0; j < cmpBytes.length; ++j) {
+ high = (byte) ((bytes[i++] & PIECE_MASK) << PIECE_LENGTH);
+ low = (byte) (bytes[i++] & PIECE_MASK);
+ cmpBytes[j] = (byte) (high | low);
+ }
+ return cmpBytes;
+ }
+
+ private EtudeUtils() {
+ throw new AssertionError(
+ "No org.hedgecode.chess.EtudeUtils instances!"
+ );
+ }
+
+
+ public static void main(String... args) {
+ System.out.println(
+ hashPosition(Positions.INITIAL.getPosition())
+ );
+ System.out.println(
+ Arrays.toString(blobPosition(Positions.INITIAL.getPosition()))
+ );
+ }
+
+}
git.hedgecode.org / chesshog.git / blobdiff