Current section
Files
Jump to
Current section
Files
src/game.erl
-module(game).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([to_fen/1, new_game_without_status/0, new_game/0, from_fen_string/1, apply_move_raw/2, disable_status/1, undo_move/1, print_board/1, print_board_from_fen/1, all_legal_moves/1, apply_move/2, apply_move_san_string/2, load_pgn/1, apply_move_uci/2]).
-export_type([game/0]).
-type game() :: {game,
board:board_bb(),
color:color(),
list(move:move_with_capture()),
gleam@option:option(status:status()),
integer(),
castle_rights:castle_rights(),
castle_rights:castle_rights(),
castle_rights:castle_rights(),
castle_rights:castle_rights(),
gleam@option:option(position:position())}.
-spec to_fen(game()) -> binary().
to_fen(Game) ->
Halfmove@1 = case erlang:element(5, Game) of
none ->
0;
{some, {in_progress, Halfmove, _}} ->
Halfmove;
{some, {draw, _}} ->
0;
{some, _} ->
0
end,
Game_fen = {fen,
erlang:element(2, Game),
erlang:element(3, Game),
{castling_status,
castle_rights:to_bool(erlang:element(7, Game)),
castle_rights:to_bool(erlang:element(8, Game)),
castle_rights:to_bool(erlang:element(9, Game)),
castle_rights:to_bool(erlang:element(10, Game))},
erlang:element(11, Game),
Halfmove@1,
(erlang:element(6, Game) div 2) + 1},
fen:to_string(Game_fen).
-spec new_game_without_status() -> game().
new_game_without_status() ->
White_king_bitboard = 2#0000000000000000000000000000000000000000000000000000000000001000,
White_queen_bitboard = 2#0000000000000000000000000000000000000000000000000000000000010000,
White_rook_bitboard = 2#0000000000000000000000000000000000000000000000000000000010000001,
White_bishop_bitboard = 2#0000000000000000000000000000000000000000000000000000000000100100,
White_knight_bitboard = 2#0000000000000000000000000000000000000000000000000000000001000010,
White_pawns_bitboard = 2#0000000000000000000000000000000000000000000000001111111100000000,
Black_king_bitboard = 2#0000100000000000000000000000000000000000000000000000000000000000,
Black_queen_bitboard = 2#0001000000000000000000000000000000000000000000000000000000000000,
Black_rook_bitboard = 2#1000000100000000000000000000000000000000000000000000000000000000,
Black_bishop_bitboard = 2#0010010000000000000000000000000000000000000000000000000000000000,
Black_knight_bitboard = 2#0100001000000000000000000000000000000000000000000000000000000000,
Black_pawns_bitboard = 2#0000000011111111000000000000000000000000000000000000000000000000,
Board = {board_bb,
Black_king_bitboard,
Black_queen_bitboard,
Black_rook_bitboard,
Black_bishop_bitboard,
Black_knight_bitboard,
Black_pawns_bitboard,
White_king_bitboard,
White_queen_bitboard,
White_rook_bitboard,
White_bishop_bitboard,
White_knight_bitboard,
White_pawns_bitboard},
Turn = white,
History = [],
Status = none,
Ply = 0,
{game, Board, Turn, History, Status, Ply, yes, yes, yes, yes, none}.
-spec new_game() -> game().
new_game() ->
White_king_bitboard = 2#0000000000000000000000000000000000000000000000000000000000010000,
White_queen_bitboard = 2#0000000000000000000000000000000000000000000000000000000000001000,
White_rook_bitboard = 2#0000000000000000000000000000000000000000000000000000000010000001,
White_bishop_bitboard = 2#0000000000000000000000000000000000000000000000000000000000100100,
White_knight_bitboard = 2#0000000000000000000000000000000000000000000000000000000001000010,
White_pawns_bitboard = 2#0000000000000000000000000000000000000000000000001111111100000000,
Black_king_bitboard = 2#0001000000000000000000000000000000000000000000000000000000000000,
Black_queen_bitboard = 2#0000100000000000000000000000000000000000000000000000000000000000,
Black_rook_bitboard = 2#1000000100000000000000000000000000000000000000000000000000000000,
Black_bishop_bitboard = 2#0010010000000000000000000000000000000000000000000000000000000000,
Black_knight_bitboard = 2#0100001000000000000000000000000000000000000000000000000000000000,
Black_pawns_bitboard = 2#0000000011111111000000000000000000000000000000000000000000000000,
Board = {board_bb,
Black_king_bitboard,
Black_queen_bitboard,
Black_rook_bitboard,
Black_bishop_bitboard,
Black_knight_bitboard,
Black_pawns_bitboard,
White_king_bitboard,
White_queen_bitboard,
White_rook_bitboard,
White_bishop_bitboard,
White_knight_bitboard,
White_pawns_bitboard},
Turn = white,
History = [],
Status = {in_progress, 0, gleam@dict:new()},
Ply = 0,
{game, Board, Turn, History, {some, Status}, Ply, yes, yes, yes, yes, none}.
-spec from_fen_string(binary()) -> {ok, game()} | {error, any()}.
from_fen_string(Fen_string) ->
Fen = fen:from_string(Fen_string),
Status = {in_progress, erlang:element(6, Fen), gleam@dict:new()},
Ply = case erlang:element(3, Fen) of
white ->
(erlang:element(7, Fen) - 1) * 2;
black ->
((erlang:element(7, Fen) - 1) * 2) + 1
end,
White_kingside_castle = case erlang:element(2, erlang:element(4, Fen)) of
true ->
yes;
false ->
{no, 1}
end,
White_queenside_castle = case erlang:element(3, erlang:element(4, Fen)) of
true ->
yes;
false ->
{no, 1}
end,
Black_kingside_castle = case erlang:element(4, erlang:element(4, Fen)) of
true ->
yes;
false ->
{no, 2}
end,
Black_queenside_castle = case erlang:element(5, erlang:element(4, Fen)) of
true ->
yes;
false ->
{no, 2}
end,
{ok,
{game,
erlang:element(2, Fen),
erlang:element(3, Fen),
[],
{some, Status},
Ply,
White_kingside_castle,
White_queenside_castle,
Black_kingside_castle,
Black_queenside_castle,
erlang:element(5, Fen)}}.
-spec look_up_knight_target_bb(position:position()) -> integer().
look_up_knight_target_bb(Origin_square) ->
case Origin_square of
{position, a, one} ->
2#0000000000000000000000000000000000000000000000100000010000000000;
{position, a, two} ->
2#0000000000000000000000000000000000000010000001000000000000000100;
{position, a, three} ->
2#0000000000000000000000000000001000000100000000000000010000000010;
{position, a, four} ->
2#0000000000000000000000100000010000000000000001000000001000000000;
{position, a, five} ->
2#0000000000000010000001000000000000000100000000100000000000000000;
{position, a, six} ->
2#0000001000000100000000000000010000000010000000000000000000000000;
{position, a, seven} ->
2#0000010000000000000001000000001000000000000000000000000000000000;
{position, a, eight} ->
2#0000000000000100000000100000000000000000000000000000000000000000;
{position, b, one} ->
2#0000000000000000000000000000000000000000000001010000100000000000;
{position, b, two} ->
2#0000000000000000000000000000000000000101000010000000000000001000;
{position, b, three} ->
2#0000000000000000000000000000010100001000000000000000100000000101;
{position, b, four} ->
2#0000000000000000000001010000100000000000000010000000010100000000;
{position, b, five} ->
2#0000000000000101000010000000000000001000000001010000000000000000;
{position, b, six} ->
2#0000010100001000000000000000100000000101000000000000000000000000;
{position, b, seven} ->
2#0000100000000000000010000000010100000000000000000000000000000000;
{position, b, eight} ->
2#0000000000001000000001010000000000000000000000000000000000000000;
{position, c, one} ->
2#0000000000000000000000000000000000000000000010100001000100000000;
{position, c, two} ->
2#0000000000000000000000000000000000001010000100010000000000010001;
{position, c, three} ->
2#0000000000000000000000000000101000010001000000000001000100001010;
{position, c, four} ->
2#0000000000000000000010100001000100000000000100010000101000000000;
{position, c, five} ->
2#0000000000001010000100010000000000010001000010100000000000000000;
{position, c, six} ->
2#0000101000010001000000000001000100001010000000000000000000000000;
{position, c, seven} ->
2#0001000100000000000100010000101000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000010001000010100000000000000000000000000000000000000000;
{position, d, one} ->
2#0000000000000000000000000000000000000000000101000010001000000000;
{position, d, two} ->
2#0000000000000000000000000000000000010100001000100000000000100010;
{position, d, three} ->
2#0000000000000000000000000001010000100010000000000010001000010100;
{position, d, four} ->
2#0000000000000000000101000010001000000000001000100001010000000000;
{position, d, five} ->
2#0000000000010100001000100000000000100010000101000000000000000000;
{position, d, six} ->
2#0001010000100010000000000010001000010100000000000000000000000000;
{position, d, seven} ->
2#0010001000000000001000100001010000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000100010000101000000000000000000000000000000000000000000;
{position, e, one} ->
2#0000000000000000000000000000000000000000001010000100010000000000;
{position, e, two} ->
2#0000000000000000000000000000000000101000010001000000000001000100;
{position, e, three} ->
2#0000000000000000000000000010100001000100000000000100010000101000;
{position, e, four} ->
2#0000000000000000001010000100010000000000010001000010100000000000;
{position, e, five} ->
2#0000000000101000010001000000000001000100001010000000000000000000;
{position, e, six} ->
2#0010100001000100000000000100010000101000000000000000000000000000;
{position, e, seven} ->
2#0100010000000000010001000010100000000000000000000000000000000000;
{position, e, eight} ->
2#0000000001000100001010000000000000000000000000000000000000000000;
{position, f, one} ->
2#0000000000000000000000000000000000000000010100001000100000000000;
{position, f, two} ->
2#0000000000000000000000000000000001010000100010000000000010001000;
{position, f, three} ->
2#0000000000000000000000000101000010001000000000001000100001010000;
{position, f, four} ->
2#0000000000000000010100001000100000000000100010000101000000000000;
{position, f, five} ->
2#0000000001010000100010000000000010001000010100000000000000000000;
{position, f, six} ->
2#0101000010001000000000001000100001010000000000000000000000000000;
{position, f, seven} ->
2#1000100000000000100010000101000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000010001000010100000000000000000000000000000000000000000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000101000000001000000000000;
{position, g, two} ->
2#0000000000000000000000000000000010100000000100000000000000010000;
{position, g, three} ->
2#0000000000000000000000001010000000010000000000000001000010100000;
{position, g, four} ->
2#0000000000000000101000000001000000000000000100001010000000000000;
{position, g, five} ->
2#0000000010100000000100000000000000010000101000000000000000000000;
{position, g, six} ->
2#1010000000010000000000000001000010100000000000000000000000000000;
{position, g, seven} ->
2#0001000000000000000100001010000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000000010000101000000000000000000000000000000000000000000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000010000000010000000000000;
{position, h, two} ->
2#0000000000000000000000000000000001000000001000000000000000100000;
{position, h, three} ->
2#0000000000000000000000000100000000100000000000000010000001000000;
{position, h, four} ->
2#0000000000000000010000000010000000000000001000000100000000000000;
{position, h, five} ->
2#0000000001000000001000000000000000100000010000000000000000000000;
{position, h, six} ->
2#0100000000100000000000000010000001000000000000000000000000000000;
{position, h, seven} ->
2#0010000000000000001000000100000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000000100000010000000000000000000000000000000000000000000000
end.
-spec look_up_east_ray_bb(position:position()) -> integer().
look_up_east_ray_bb(Origin_square) ->
case Origin_square of
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000011111110;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000001111111000000000;
{position, a, three} ->
2#0000000000000000000000000000000000000000111111100000000000000000;
{position, a, four} ->
2#0000000000000000000000000000000011111110000000000000000000000000;
{position, a, five} ->
2#0000000000000000000000001111111000000000000000000000000000000000;
{position, a, six} ->
2#0000000000000000111111100000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000000011111110000000000000000000000000000000000000000000000000;
{position, a, eight} ->
2#1111111000000000000000000000000000000000000000000000000000000000;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000011111100;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000001111110000000000;
{position, b, three} ->
2#0000000000000000000000000000000000000000111111000000000000000000;
{position, b, four} ->
2#0000000000000000000000000000000011111100000000000000000000000000;
{position, b, five} ->
2#0000000000000000000000001111110000000000000000000000000000000000;
{position, b, six} ->
2#0000000000000000111111000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000000011111100000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#1111110000000000000000000000000000000000000000000000000000000000;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000000000000011111000;
{position, c, two} ->
2#0000000000000000000000000000000000000000000000001111100000000000;
{position, c, three} ->
2#0000000000000000000000000000000000000000111110000000000000000000;
{position, c, four} ->
2#0000000000000000000000000000000011111000000000000000000000000000;
{position, c, five} ->
2#0000000000000000000000001111100000000000000000000000000000000000;
{position, c, six} ->
2#0000000000000000111110000000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000000011111000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#1111100000000000000000000000000000000000000000000000000000000000;
{position, d, one} ->
2#0000000000000000000000000000000000000000000000000000000011110000;
{position, d, two} ->
2#0000000000000000000000000000000000000000000000001111000000000000;
{position, d, three} ->
2#0000000000000000000000000000000000000000111100000000000000000000;
{position, d, four} ->
2#0000000000000000000000000000000011110000000000000000000000000000;
{position, d, five} ->
2#0000000000000000000000001111000000000000000000000000000000000000;
{position, d, six} ->
2#0000000000000000111100000000000000000000000000000000000000000000;
{position, d, seven} ->
2#0000000011110000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#1111000000000000000000000000000000000000000000000000000000000000;
{position, e, one} ->
2#0000000000000000000000000000000000000000000000000000000011100000;
{position, e, two} ->
2#0000000000000000000000000000000000000000000000001110000000000000;
{position, e, three} ->
2#0000000000000000000000000000000000000000111000000000000000000000;
{position, e, four} ->
2#0000000000000000000000000000000011100000000000000000000000000000;
{position, e, five} ->
2#0000000000000000000000001110000000000000000000000000000000000000;
{position, e, six} ->
2#0000000000000000111000000000000000000000000000000000000000000000;
{position, e, seven} ->
2#0000000011100000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#1110000000000000000000000000000000000000000000000000000000000000;
{position, f, one} ->
2#0000000000000000000000000000000000000000000000000000000011000000;
{position, f, two} ->
2#0000000000000000000000000000000000000000000000001100000000000000;
{position, f, three} ->
2#0000000000000000000000000000000000000000110000000000000000000000;
{position, f, four} ->
2#0000000000000000000000000000000011000000000000000000000000000000;
{position, f, five} ->
2#0000000000000000000000001100000000000000000000000000000000000000;
{position, f, six} ->
2#0000000000000000110000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0000000011000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#1100000000000000000000000000000000000000000000000000000000000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000000000000010000000;
{position, g, two} ->
2#0000000000000000000000000000000000000000000000001000000000000000;
{position, g, three} ->
2#0000000000000000000000000000000000000000100000000000000000000000;
{position, g, four} ->
2#0000000000000000000000000000000010000000000000000000000000000000;
{position, g, five} ->
2#0000000000000000000000001000000000000000000000000000000000000000;
{position, g, six} ->
2#0000000000000000100000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#0000000010000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#1000000000000000000000000000000000000000000000000000000000000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_north_ray_bb(position:position()) -> integer().
look_up_north_ray_bb(Origin_square) ->
case Origin_square of
{position, a, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000000100000000000000000000000000000000000000000000000000000000;
{position, a, six} ->
2#0000000100000001000000000000000000000000000000000000000000000000;
{position, a, five} ->
2#0000000100000001000000010000000000000000000000000000000000000000;
{position, a, four} ->
2#0000000100000001000000010000000100000000000000000000000000000000;
{position, a, three} ->
2#0000000100000001000000010000000100000001000000000000000000000000;
{position, a, two} ->
2#0000000100000001000000010000000100000001000000010000000000000000;
{position, a, one} ->
2#0000000100000001000000010000000100000001000000010000000100000000;
{position, b, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000001000000000000000000000000000000000000000000000000000000000;
{position, b, six} ->
2#0000001000000010000000000000000000000000000000000000000000000000;
{position, b, five} ->
2#0000001000000010000000100000000000000000000000000000000000000000;
{position, b, four} ->
2#0000001000000010000000100000001000000000000000000000000000000000;
{position, b, three} ->
2#0000001000000010000000100000001000000010000000000000000000000000;
{position, b, two} ->
2#0000001000000010000000100000001000000010000000100000000000000000;
{position, b, one} ->
2#0000001000000010000000100000001000000010000000100000001000000000;
{position, c, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000010000000000000000000000000000000000000000000000000000000000;
{position, c, six} ->
2#0000010000000100000000000000000000000000000000000000000000000000;
{position, c, five} ->
2#0000010000000100000001000000000000000000000000000000000000000000;
{position, c, four} ->
2#0000010000000100000001000000010000000000000000000000000000000000;
{position, c, three} ->
2#0000010000000100000001000000010000000100000000000000000000000000;
{position, c, two} ->
2#0000010000000100000001000000010000000100000001000000000000000000;
{position, c, one} ->
2#0000010000000100000001000000010000000100000001000000010000000000;
{position, d, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, seven} ->
2#0000100000000000000000000000000000000000000000000000000000000000;
{position, d, six} ->
2#0000100000001000000000000000000000000000000000000000000000000000;
{position, d, five} ->
2#0000100000001000000010000000000000000000000000000000000000000000;
{position, d, four} ->
2#0000100000001000000010000000100000000000000000000000000000000000;
{position, d, three} ->
2#0000100000001000000010000000100000001000000000000000000000000000;
{position, d, two} ->
2#0000100000001000000010000000100000001000000010000000000000000000;
{position, d, one} ->
2#0000100000001000000010000000100000001000000010000000100000000000;
{position, e, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, seven} ->
2#0001000000000000000000000000000000000000000000000000000000000000;
{position, e, six} ->
2#0001000000010000000000000000000000000000000000000000000000000000;
{position, e, five} ->
2#0001000000010000000100000000000000000000000000000000000000000000;
{position, e, four} ->
2#0001000000010000000100000001000000000000000000000000000000000000;
{position, e, three} ->
2#0001000000010000000100000001000000010000000000000000000000000000;
{position, e, two} ->
2#0001000000010000000100000001000000010000000100000000000000000000;
{position, e, one} ->
2#0001000000010000000100000001000000010000000100000001000000000000;
{position, f, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0010000000000000000000000000000000000000000000000000000000000000;
{position, f, six} ->
2#0010000000100000000000000000000000000000000000000000000000000000;
{position, f, five} ->
2#0010000000100000001000000000000000000000000000000000000000000000;
{position, f, four} ->
2#0010000000100000001000000010000000000000000000000000000000000000;
{position, f, three} ->
2#0010000000100000001000000010000000100000000000000000000000000000;
{position, f, two} ->
2#0010000000100000001000000010000000100000001000000000000000000000;
{position, f, one} ->
2#0010000000100000001000000010000000100000001000000010000000000000;
{position, g, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#0100000000000000000000000000000000000000000000000000000000000000;
{position, g, six} ->
2#0100000001000000000000000000000000000000000000000000000000000000;
{position, g, five} ->
2#0100000001000000010000000000000000000000000000000000000000000000;
{position, g, four} ->
2#0100000001000000010000000100000000000000000000000000000000000000;
{position, g, three} ->
2#0100000001000000010000000100000001000000000000000000000000000000;
{position, g, two} ->
2#0100000001000000010000000100000001000000010000000000000000000000;
{position, g, one} ->
2#0100000001000000010000000100000001000000010000000100000000000000;
{position, h, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#1000000000000000000000000000000000000000000000000000000000000000;
{position, h, six} ->
2#1000000010000000000000000000000000000000000000000000000000000000;
{position, h, five} ->
2#1000000010000000100000000000000000000000000000000000000000000000;
{position, h, four} ->
2#1000000010000000100000001000000000000000000000000000000000000000;
{position, h, three} ->
2#1000000010000000100000001000000010000000000000000000000000000000;
{position, h, two} ->
2#1000000010000000100000001000000010000000100000000000000000000000;
{position, h, one} ->
2#1000000010000000100000001000000010000000100000001000000000000000
end.
-spec look_up_west_ray_bb(position:position()) -> integer().
look_up_west_ray_bb(Origin_square) ->
case Origin_square of
{position, h, eight} ->
2#0111111100000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#0000000001111111000000000000000000000000000000000000000000000000;
{position, h, six} ->
2#0000000000000000011111110000000000000000000000000000000000000000;
{position, h, five} ->
2#0000000000000000000000000111111100000000000000000000000000000000;
{position, h, four} ->
2#0000000000000000000000000000000001111111000000000000000000000000;
{position, h, three} ->
2#0000000000000000000000000000000000000000011111110000000000000000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000111111100000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000001111111;
{position, g, eight} ->
2#0011111100000000000000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#0000000000111111000000000000000000000000000000000000000000000000;
{position, g, six} ->
2#0000000000000000001111110000000000000000000000000000000000000000;
{position, g, five} ->
2#0000000000000000000000000011111100000000000000000000000000000000;
{position, g, four} ->
2#0000000000000000000000000000000000111111000000000000000000000000;
{position, g, three} ->
2#0000000000000000000000000000000000000000001111110000000000000000;
{position, g, two} ->
2#0000000000000000000000000000000000000000000000000011111100000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000000000000000111111;
{position, f, eight} ->
2#0001111100000000000000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0000000000011111000000000000000000000000000000000000000000000000;
{position, f, six} ->
2#0000000000000000000111110000000000000000000000000000000000000000;
{position, f, five} ->
2#0000000000000000000000000001111100000000000000000000000000000000;
{position, f, four} ->
2#0000000000000000000000000000000000011111000000000000000000000000;
{position, f, three} ->
2#0000000000000000000000000000000000000000000111110000000000000000;
{position, f, two} ->
2#0000000000000000000000000000000000000000000000000001111100000000;
{position, f, one} ->
2#0000000000000000000000000000000000000000000000000000000000011111;
{position, e, eight} ->
2#0000111100000000000000000000000000000000000000000000000000000000;
{position, e, seven} ->
2#0000000000001111000000000000000000000000000000000000000000000000;
{position, e, six} ->
2#0000000000000000000011110000000000000000000000000000000000000000;
{position, e, five} ->
2#0000000000000000000000000000111100000000000000000000000000000000;
{position, e, four} ->
2#0000000000000000000000000000000000001111000000000000000000000000;
{position, e, three} ->
2#0000000000000000000000000000000000000000000011110000000000000000;
{position, e, two} ->
2#0000000000000000000000000000000000000000000000000000111100000000;
{position, e, one} ->
2#0000000000000000000000000000000000000000000000000000000000001111;
{position, d, eight} ->
2#0000011100000000000000000000000000000000000000000000000000000000;
{position, d, seven} ->
2#0000000000000111000000000000000000000000000000000000000000000000;
{position, d, six} ->
2#0000000000000000000001110000000000000000000000000000000000000000;
{position, d, five} ->
2#0000000000000000000000000000011100000000000000000000000000000000;
{position, d, four} ->
2#0000000000000000000000000000000000000111000000000000000000000000;
{position, d, three} ->
2#0000000000000000000000000000000000000000000001110000000000000000;
{position, d, two} ->
2#0000000000000000000000000000000000000000000000000000011100000000;
{position, d, one} ->
2#0000000000000000000000000000000000000000000000000000000000000111;
{position, c, eight} ->
2#0000001100000000000000000000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000000000000011000000000000000000000000000000000000000000000000;
{position, c, six} ->
2#0000000000000000000000110000000000000000000000000000000000000000;
{position, c, five} ->
2#0000000000000000000000000000001100000000000000000000000000000000;
{position, c, four} ->
2#0000000000000000000000000000000000000011000000000000000000000000;
{position, c, three} ->
2#0000000000000000000000000000000000000000000000110000000000000000;
{position, c, two} ->
2#0000000000000000000000000000000000000000000000000000001100000000;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000000000000000000011;
{position, b, eight} ->
2#0000000100000000000000000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000000000000001000000000000000000000000000000000000000000000000;
{position, b, six} ->
2#0000000000000000000000010000000000000000000000000000000000000000;
{position, b, five} ->
2#0000000000000000000000000000000100000000000000000000000000000000;
{position, b, four} ->
2#0000000000000000000000000000000000000001000000000000000000000000;
{position, b, three} ->
2#0000000000000000000000000000000000000000000000010000000000000000;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000000000000100000000;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000000000001;
{position, a, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_south_ray_bb(position:position()) -> integer().
look_up_south_ray_bb(Origin_square) ->
case Origin_square of
{position, a, eight} ->
2#0000000000000001000000010000000100000001000000010000000100000001;
{position, a, seven} ->
2#0000000000000000000000010000000100000001000000010000000100000001;
{position, a, six} ->
2#0000000000000000000000000000000100000001000000010000000100000001;
{position, a, five} ->
2#0000000000000000000000000000000000000001000000010000000100000001;
{position, a, four} ->
2#0000000000000000000000000000000000000000000000010000000100000001;
{position, a, three} ->
2#0000000000000000000000000000000000000000000000000000000100000001;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000000000000000000001;
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#0000000000000010000000100000001000000010000000100000001000000010;
{position, b, seven} ->
2#0000000000000000000000100000001000000010000000100000001000000010;
{position, b, six} ->
2#0000000000000000000000000000001000000010000000100000001000000010;
{position, b, five} ->
2#0000000000000000000000000000000000000010000000100000001000000010;
{position, b, four} ->
2#0000000000000000000000000000000000000000000000100000001000000010;
{position, b, three} ->
2#0000000000000000000000000000000000000000000000000000001000000010;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000000000000000000010;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000000100000001000000010000000100000001000000010000000100;
{position, c, seven} ->
2#0000000000000000000001000000010000000100000001000000010000000100;
{position, c, six} ->
2#0000000000000000000000000000010000000100000001000000010000000100;
{position, c, five} ->
2#0000000000000000000000000000000000000100000001000000010000000100;
{position, c, four} ->
2#0000000000000000000000000000000000000000000001000000010000000100;
{position, c, three} ->
2#0000000000000000000000000000000000000000000000000000010000000100;
{position, c, two} ->
2#0000000000000000000000000000000000000000000000000000000000000100;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000001000000010000000100000001000000010000000100000001000;
{position, d, seven} ->
2#0000000000000000000010000000100000001000000010000000100000001000;
{position, d, six} ->
2#0000000000000000000000000000100000001000000010000000100000001000;
{position, d, five} ->
2#0000000000000000000000000000000000001000000010000000100000001000;
{position, d, four} ->
2#0000000000000000000000000000000000000000000010000000100000001000;
{position, d, three} ->
2#0000000000000000000000000000000000000000000000000000100000001000;
{position, d, two} ->
2#0000000000000000000000000000000000000000000000000000000000001000;
{position, d, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#0000000000010000000100000001000000010000000100000001000000010000;
{position, e, seven} ->
2#0000000000000000000100000001000000010000000100000001000000010000;
{position, e, six} ->
2#0000000000000000000000000001000000010000000100000001000000010000;
{position, e, five} ->
2#0000000000000000000000000000000000010000000100000001000000010000;
{position, e, four} ->
2#0000000000000000000000000000000000000000000100000001000000010000;
{position, e, three} ->
2#0000000000000000000000000000000000000000000000000001000000010000;
{position, e, two} ->
2#0000000000000000000000000000000000000000000000000000000000010000;
{position, e, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000000100000001000000010000000100000001000000010000000100000;
{position, f, seven} ->
2#0000000000000000001000000010000000100000001000000010000000100000;
{position, f, six} ->
2#0000000000000000000000000010000000100000001000000010000000100000;
{position, f, five} ->
2#0000000000000000000000000000000000100000001000000010000000100000;
{position, f, four} ->
2#0000000000000000000000000000000000000000001000000010000000100000;
{position, f, three} ->
2#0000000000000000000000000000000000000000000000000010000000100000;
{position, f, two} ->
2#0000000000000000000000000000000000000000000000000000000000100000;
{position, f, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000001000000010000000100000001000000010000000100000001000000;
{position, g, seven} ->
2#0000000000000000010000000100000001000000010000000100000001000000;
{position, g, six} ->
2#0000000000000000000000000100000001000000010000000100000001000000;
{position, g, five} ->
2#0000000000000000000000000000000001000000010000000100000001000000;
{position, g, four} ->
2#0000000000000000000000000000000000000000010000000100000001000000;
{position, g, three} ->
2#0000000000000000000000000000000000000000000000000100000001000000;
{position, g, two} ->
2#0000000000000000000000000000000000000000000000000000000001000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000010000000100000001000000010000000100000001000000010000000;
{position, h, seven} ->
2#0000000000000000100000001000000010000000100000001000000010000000;
{position, h, six} ->
2#0000000000000000000000001000000010000000100000001000000010000000;
{position, h, five} ->
2#0000000000000000000000000000000010000000100000001000000010000000;
{position, h, four} ->
2#0000000000000000000000000000000000000000100000001000000010000000;
{position, h, three} ->
2#0000000000000000000000000000000000000000000000001000000010000000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000000000010000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_south_west_ray_bb(position:position()) -> integer().
look_up_south_west_ray_bb(Origin_square) ->
case Origin_square of
{position, a, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#0000000000000001000000000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000000000000000000000010000000000000000000000000000000000000000;
{position, b, six} ->
2#0000000000000000000000000000000100000000000000000000000000000000;
{position, b, five} ->
2#0000000000000000000000000000000000000001000000000000000000000000;
{position, b, four} ->
2#0000000000000000000000000000000000000000000000010000000000000000;
{position, b, three} ->
2#0000000000000000000000000000000000000000000000000000000100000000;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000000000000000000001;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000000010000000010000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000000000000000000000100000000100000000000000000000000000000000;
{position, c, six} ->
2#0000000000000000000000000000001000000001000000000000000000000000;
{position, c, five} ->
2#0000000000000000000000000000000000000010000000010000000000000000;
{position, c, four} ->
2#0000000000000000000000000000000000000000000000100000000100000000;
{position, c, three} ->
2#0000000000000000000000000000000000000000000000000000001000000001;
{position, c, two} ->
2#0000000000000000000000000000000000000000000000000000000000000010;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000000100000000100000000100000000000000000000000000000000;
{position, d, seven} ->
2#0000000000000000000001000000001000000001000000000000000000000000;
{position, d, six} ->
2#0000000000000000000000000000010000000010000000010000000000000000;
{position, d, five} ->
2#0000000000000000000000000000000000000100000000100000000100000000;
{position, d, four} ->
2#0000000000000000000000000000000000000000000001000000001000000001;
{position, d, three} ->
2#0000000000000000000000000000000000000000000000000000010000000010;
{position, d, two} ->
2#0000000000000000000000000000000000000000000000000000000000000100;
{position, d, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#0000000000001000000001000000001000000001000000000000000000000000;
{position, e, seven} ->
2#0000000000000000000010000000010000000010000000010000000000000000;
{position, e, six} ->
2#0000000000000000000000000000100000000100000000100000000100000000;
{position, e, five} ->
2#0000000000000000000000000000000000001000000001000000001000000001;
{position, e, four} ->
2#0000000000000000000000000000000000000000000010000000010000000010;
{position, e, three} ->
2#0000000000000000000000000000000000000000000000000000100000000100;
{position, e, two} ->
2#0000000000000000000000000000000000000000000000000000000000001000;
{position, e, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000000010000000010000000010000000010000000010000000000000000;
{position, f, seven} ->
2#0000000000000000000100000000100000000100000000100000000100000000;
{position, f, six} ->
2#0000000000000000000000000001000000001000000001000000001000000001;
{position, f, five} ->
2#0000000000000000000000000000000000010000000010000000010000000010;
{position, f, four} ->
2#0000000000000000000000000000000000000000000100000000100000000100;
{position, f, three} ->
2#0000000000000000000000000000000000000000000000000001000000001000;
{position, f, two} ->
2#0000000000000000000000000000000000000000000000000000000000010000;
{position, f, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000000100000000100000000100000000100000000100000000100000000;
{position, g, seven} ->
2#0000000000000000001000000001000000001000000001000000001000000001;
{position, g, six} ->
2#0000000000000000000000000010000000010000000010000000010000000010;
{position, g, five} ->
2#0000000000000000000000000000000000100000000100000000100000000100;
{position, g, four} ->
2#0000000000000000000000000000000000000000001000000001000000001000;
{position, g, three} ->
2#0000000000000000000000000000000000000000000000000010000000010000;
{position, g, two} ->
2#0000000000000000000000000000000000000000000000000000000000100000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000001000000001000000001000000001000000001000000001000000001;
{position, h, seven} ->
2#0000000000000000010000000010000000010000000010000000010000000010;
{position, h, six} ->
2#0000000000000000000000000100000000100000000100000000100000000100;
{position, h, five} ->
2#0000000000000000000000000000000001000000001000000001000000001000;
{position, h, four} ->
2#0000000000000000000000000000000000000000010000000010000000010000;
{position, h, three} ->
2#0000000000000000000000000000000000000000000000000100000000100000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000000000001000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_south_east_ray_bb(position:position()) -> integer().
look_up_south_east_ray_bb(Origin_square) ->
case Origin_square of
{position, a, eight} ->
2#0000000000000010000001000000100000010000001000000100000010000000;
{position, a, seven} ->
2#0000000000000000000000100000010000001000000100000010000001000000;
{position, a, six} ->
2#0000000000000000000000000000001000000100000010000001000000100000;
{position, a, five} ->
2#0000000000000000000000000000000000000010000001000000100000010000;
{position, a, four} ->
2#0000000000000000000000000000000000000000000000100000010000001000;
{position, a, three} ->
2#0000000000000000000000000000000000000000000000000000001000000100;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000000000000000000010;
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#0000000000000100000010000001000000100000010000001000000000000000;
{position, b, seven} ->
2#0000000000000000000001000000100000010000001000000100000010000000;
{position, b, six} ->
2#0000000000000000000000000000010000001000000100000010000001000000;
{position, b, five} ->
2#0000000000000000000000000000000000000100000010000001000000100000;
{position, b, four} ->
2#0000000000000000000000000000000000000000000001000000100000010000;
{position, b, three} ->
2#0000000000000000000000000000000000000000000000000000010000001000;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000000000000000000100;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000001000000100000010000001000000100000000000000000000000;
{position, c, seven} ->
2#0000000000000000000010000001000000100000010000001000000000000000;
{position, c, six} ->
2#0000000000000000000000000000100000010000001000000100000010000000;
{position, c, five} ->
2#0000000000000000000000000000000000001000000100000010000001000000;
{position, c, four} ->
2#0000000000000000000000000000000000000000000010000001000000100000;
{position, c, three} ->
2#0000000000000000000000000000000000000000000000000000100000010000;
{position, c, two} ->
2#0000000000000000000000000000000000000000000000000000000000001000;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000010000001000000100000010000000000000000000000000000000;
{position, d, seven} ->
2#0000000000000000000100000010000001000000100000000000000000000000;
{position, d, six} ->
2#0000000000000000000000000001000000100000010000001000000000000000;
{position, d, five} ->
2#0000000000000000000000000000000000010000001000000100000010000000;
{position, d, four} ->
2#0000000000000000000000000000000000000000000100000010000001000000;
{position, d, three} ->
2#0000000000000000000000000000000000000000000000000001000000100000;
{position, d, two} ->
2#0000000000000000000000000000000000000000000000000000000000010000;
{position, d, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#0000000000100000010000001000000000000000000000000000000000000000;
{position, e, seven} ->
2#0000000000000000001000000100000010000000000000000000000000000000;
{position, e, six} ->
2#0000000000000000000000000010000001000000100000000000000000000000;
{position, e, five} ->
2#0000000000000000000000000000000000100000010000001000000000000000;
{position, e, four} ->
2#0000000000000000000000000000000000000000001000000100000010000000;
{position, e, three} ->
2#0000000000000000000000000000000000000000000000000010000001000000;
{position, e, two} ->
2#0000000000000000000000000000000000000000000000000000000000100000;
{position, e, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000001000000100000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0000000000000000010000001000000000000000000000000000000000000000;
{position, f, six} ->
2#0000000000000000000000000100000010000000000000000000000000000000;
{position, f, five} ->
2#0000000000000000000000000000000001000000100000000000000000000000;
{position, f, four} ->
2#0000000000000000000000000000000000000000010000001000000000000000;
{position, f, three} ->
2#0000000000000000000000000000000000000000000000000100000010000000;
{position, f, two} ->
2#0000000000000000000000000000000000000000000000000000000001000000;
{position, f, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000010000000000000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#0000000000000000100000000000000000000000000000000000000000000000;
{position, g, six} ->
2#0000000000000000000000001000000000000000000000000000000000000000;
{position, g, five} ->
2#0000000000000000000000000000000010000000000000000000000000000000;
{position, g, four} ->
2#0000000000000000000000000000000000000000100000000000000000000000;
{position, g, three} ->
2#0000000000000000000000000000000000000000000000001000000000000000;
{position, g, two} ->
2#0000000000000000000000000000000000000000000000000000000010000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_north_east_ray_bb(position:position()) -> integer().
look_up_north_east_ray_bb(Origin_square) ->
case Origin_square of
{position, a, one} ->
2#1000000001000000001000000001000000001000000001000000001000000000;
{position, a, two} ->
2#0100000000100000000100000000100000000100000000100000000000000000;
{position, a, three} ->
2#0010000000010000000010000000010000000010000000000000000000000000;
{position, a, four} ->
2#0001000000001000000001000000001000000000000000000000000000000000;
{position, a, five} ->
2#0000100000000100000000100000000000000000000000000000000000000000;
{position, a, six} ->
2#0000010000000010000000000000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000001000000000000000000000000000000000000000000000000000000000;
{position, a, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, one} ->
2#0000000010000000010000000010000000010000000010000000010000000000;
{position, b, two} ->
2#1000000001000000001000000001000000001000000001000000000000000000;
{position, b, three} ->
2#0100000000100000000100000000100000000100000000000000000000000000;
{position, b, four} ->
2#0010000000010000000010000000010000000000000000000000000000000000;
{position, b, five} ->
2#0001000000001000000001000000000000000000000000000000000000000000;
{position, b, six} ->
2#0000100000000100000000000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000010000000000000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, one} ->
2#0000000000000000100000000100000000100000000100000000100000000000;
{position, c, two} ->
2#0000000010000000010000000010000000010000000010000000000000000000;
{position, c, three} ->
2#1000000001000000001000000001000000001000000000000000000000000000;
{position, c, four} ->
2#0100000000100000000100000000100000000000000000000000000000000000;
{position, c, five} ->
2#0010000000010000000010000000000000000000000000000000000000000000;
{position, c, six} ->
2#0001000000001000000000000000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000100000000000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, one} ->
2#0000000000000000000000001000000001000000001000000001000000000000;
{position, d, two} ->
2#0000000000000000100000000100000000100000000100000000000000000000;
{position, d, three} ->
2#0000000010000000010000000010000000010000000000000000000000000000;
{position, d, four} ->
2#1000000001000000001000000001000000000000000000000000000000000000;
{position, d, five} ->
2#0100000000100000000100000000000000000000000000000000000000000000;
{position, d, six} ->
2#0010000000010000000000000000000000000000000000000000000000000000;
{position, d, seven} ->
2#0001000000000000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, one} ->
2#0000000000000000000000000000000010000000010000000010000000000000;
{position, e, two} ->
2#0000000000000000000000001000000001000000001000000000000000000000;
{position, e, three} ->
2#0000000000000000100000000100000000100000000000000000000000000000;
{position, e, four} ->
2#0000000010000000010000000010000000000000000000000000000000000000;
{position, e, five} ->
2#1000000001000000001000000000000000000000000000000000000000000000;
{position, e, six} ->
2#0100000000100000000000000000000000000000000000000000000000000000;
{position, e, seven} ->
2#0010000000000000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, one} ->
2#0000000000000000000000000000000000000000100000000100000000000000;
{position, f, two} ->
2#0000000000000000000000000000000010000000010000000000000000000000;
{position, f, three} ->
2#0000000000000000000000001000000001000000000000000000000000000000;
{position, f, four} ->
2#0000000000000000100000000100000000000000000000000000000000000000;
{position, f, five} ->
2#0000000010000000010000000000000000000000000000000000000000000000;
{position, f, six} ->
2#1000000001000000000000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0100000000000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, one} ->
2#0000000000000000000000000000000000000000000000001000000000000000;
{position, g, two} ->
2#0000000000000000000000000000000000000000100000000000000000000000;
{position, g, three} ->
2#0000000000000000000000000000000010000000000000000000000000000000;
{position, g, four} ->
2#0000000000000000000000001000000000000000000000000000000000000000;
{position, g, five} ->
2#0000000000000000100000000000000000000000000000000000000000000000;
{position, g, six} ->
2#0000000010000000000000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#1000000000000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, one} ->
2#0000000000000000000000000000000000000000000000000000000010000000;
{position, h, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec look_up_north_west_ray_bb(position:position()) -> integer().
look_up_north_west_ray_bb(Origin_square) ->
case Origin_square of
{position, a, one} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, two} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, three} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, four} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, five} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, six} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, seven} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, a, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, b, one} ->
2#0000000000000000000000000000000000000000000000000000000100000000;
{position, b, two} ->
2#0000000000000000000000000000000000000000000000010000000000000000;
{position, b, three} ->
2#0000000000000000000000000000000000000001000000000000000000000000;
{position, b, four} ->
2#0000000000000000000000000000000100000000000000000000000000000000;
{position, b, five} ->
2#0000000000000000000000010000000000000000000000000000000000000000;
{position, b, six} ->
2#0000000000000001000000000000000000000000000000000000000000000000;
{position, b, seven} ->
2#0000000100000000000000000000000000000000000000000000000000000000;
{position, b, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, c, one} ->
2#0000000000000000000000000000000000000000000000010000001000000000;
{position, c, two} ->
2#0000000000000000000000000000000000000001000000100000000000000000;
{position, c, three} ->
2#0000000000000000000000000000000100000010000000000000000000000000;
{position, c, four} ->
2#0000000000000000000000010000001000000000000000000000000000000000;
{position, c, five} ->
2#0000000000000001000000100000000000000000000000000000000000000000;
{position, c, six} ->
2#0000000100000010000000000000000000000000000000000000000000000000;
{position, c, seven} ->
2#0000001000000000000000000000000000000000000000000000000000000000;
{position, c, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, d, one} ->
2#0000000000000000000000000000000000000001000000100000010000000000;
{position, d, two} ->
2#0000000000000000000000000000000100000010000001000000000000000000;
{position, d, three} ->
2#0000000000000000000000010000001000000100000000000000000000000000;
{position, d, four} ->
2#0000000000000001000000100000010000000000000000000000000000000000;
{position, d, five} ->
2#0000000100000010000001000000000000000000000000000000000000000000;
{position, d, six} ->
2#0000001000000100000000000000000000000000000000000000000000000000;
{position, d, seven} ->
2#0000010000000000000000000000000000000000000000000000000000000000;
{position, d, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, e, one} ->
2#0000000000000000000000000000000100000010000001000000100000000000;
{position, e, two} ->
2#0000000000000000000000010000001000000100000010000000000000000000;
{position, e, three} ->
2#0000000000000001000000100000010000001000000000000000000000000000;
{position, e, four} ->
2#0000000100000010000001000000100000000000000000000000000000000000;
{position, e, five} ->
2#0000001000000100000010000000000000000000000000000000000000000000;
{position, e, six} ->
2#0000010000001000000000000000000000000000000000000000000000000000;
{position, e, seven} ->
2#0000100000000000000000000000000000000000000000000000000000000000;
{position, e, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, f, one} ->
2#0000000000000000000000010000001000000100000010000001000000000000;
{position, f, two} ->
2#0000000000000001000000100000010000001000000100000000000000000000;
{position, f, three} ->
2#0000000100000010000001000000100000010000000000000000000000000000;
{position, f, four} ->
2#0000001000000100000010000001000000000000000000000000000000000000;
{position, f, five} ->
2#0000010000001000000100000000000000000000000000000000000000000000;
{position, f, six} ->
2#0000100000010000000000000000000000000000000000000000000000000000;
{position, f, seven} ->
2#0001000000000000000000000000000000000000000000000000000000000000;
{position, f, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, g, one} ->
2#0000000000000001000000100000010000001000000100000010000000000000;
{position, g, two} ->
2#0000000100000010000001000000100000010000001000000000000000000000;
{position, g, three} ->
2#0000001000000100000010000001000000100000000000000000000000000000;
{position, g, four} ->
2#0000010000001000000100000010000000000000000000000000000000000000;
{position, g, five} ->
2#0000100000010000001000000000000000000000000000000000000000000000;
{position, g, six} ->
2#0001000000100000000000000000000000000000000000000000000000000000;
{position, g, seven} ->
2#0010000000000000000000000000000000000000000000000000000000000000;
{position, g, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000;
{position, h, one} ->
2#0000000100000010000001000000100000010000001000000100000000000000;
{position, h, two} ->
2#0000001000000100000010000001000000100000010000000000000000000000;
{position, h, three} ->
2#0000010000001000000100000010000001000000000000000000000000000000;
{position, h, four} ->
2#0000100000010000001000000100000000000000000000000000000000000000;
{position, h, five} ->
2#0001000000100000010000000000000000000000000000000000000000000000;
{position, h, six} ->
2#0010000001000000000000000000000000000000000000000000000000000000;
{position, h, seven} ->
2#0100000000000000000000000000000000000000000000000000000000000000;
{position, h, eight} ->
2#0000000000000000000000000000000000000000000000000000000000000000
end.
-spec occupied_squares(board:board_bb()) -> integer().
occupied_squares(Board) ->
List_of_all_piece_bitboards = [erlang:element(8, Board),
erlang:element(9, Board),
erlang:element(10, Board),
erlang:element(11, Board),
erlang:element(12, Board),
erlang:element(13, Board),
erlang:element(2, Board),
erlang:element(3, Board),
erlang:element(4, Board),
erlang:element(5, Board),
erlang:element(6, Board),
erlang:element(7, Board)],
gleam@list:fold(
List_of_all_piece_bitboards,
0,
fun(Collector, Next) -> bitboard:'or'(Collector, Next) end
).
-spec occupied_squares_white(board:board_bb()) -> integer().
occupied_squares_white(Board) ->
List_of_all_piece_bitboards = [erlang:element(8, Board),
erlang:element(9, Board),
erlang:element(10, Board),
erlang:element(11, Board),
erlang:element(12, Board),
erlang:element(13, Board)],
gleam@list:fold(
List_of_all_piece_bitboards,
0,
fun(Collector, Next) -> bitboard:'or'(Collector, Next) end
).
-spec occupied_squares_black(board:board_bb()) -> integer().
occupied_squares_black(Board) ->
List_of_all_piece_bitboards = [erlang:element(2, Board),
erlang:element(3, Board),
erlang:element(4, Board),
erlang:element(5, Board),
erlang:element(6, Board),
erlang:element(7, Board)],
gleam@list:fold(
List_of_all_piece_bitboards,
0,
fun(Collector, Next) -> bitboard:'or'(Collector, Next) end
).
-spec pawn_squares(color:color(), board:board_bb()) -> integer().
pawn_squares(Color, Board) ->
case Color of
white ->
erlang:element(13, Board);
black ->
erlang:element(7, Board)
end.
-spec generate_queen_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_queen_pseudo_legal_move_list(Color, Game) ->
Queen_bitboard = case Color of
white ->
erlang:element(9, erlang:element(2, Game));
black ->
erlang:element(3, erlang:element(2, Game))
end,
gleam@result:'try'(
board:get_positions(Queen_bitboard),
fun(Queen_origin_squares) ->
gleam@list:fold(
Queen_origin_squares,
{ok, []},
fun(Collector, Queen_origin_square) ->
South_mask_bb = look_up_south_ray_bb(Queen_origin_square),
East_mask_bb = look_up_east_ray_bb(Queen_origin_square),
North_mask_bb = look_up_north_ray_bb(Queen_origin_square),
West_mask_bb = look_up_west_ray_bb(Queen_origin_square),
Occupied_squares_bb = occupied_squares(
erlang:element(2, Game)
),
South_blockers_bb = bitboard:'and'(
South_mask_bb,
Occupied_squares_bb
),
East_blockers_bb = bitboard:'and'(
East_mask_bb,
Occupied_squares_bb
),
North_blockers_bb = bitboard:'and'(
North_mask_bb,
Occupied_squares_bb
),
West_blockers_bb = bitboard:'and'(
West_mask_bb,
Occupied_squares_bb
),
First_blocker_south = position:from_int(
bitboard:bitscan_backward(South_blockers_bb)
),
First_blocker_east = position:from_int(
bitboard:bitscan_forward(East_blockers_bb)
),
First_blocker_north = position:from_int(
bitboard:bitscan_forward(North_blockers_bb)
),
First_blocker_west = position:from_int(
bitboard:bitscan_backward(West_blockers_bb)
),
First_blocker_south_mask_bb = case First_blocker_south of
{error, _} ->
0;
{ok, Position} ->
look_up_south_ray_bb(Position)
end,
First_blocker_east_mask_bb = case First_blocker_east of
{error, _} ->
0;
{ok, Position@1} ->
look_up_east_ray_bb(Position@1)
end,
First_blocker_north_mask_bb = case First_blocker_north of
{error, _} ->
0;
{ok, Position@2} ->
look_up_north_ray_bb(Position@2)
end,
First_blocker_west_mask_bb = case First_blocker_west of
{error, _} ->
0;
{ok, Position@3} ->
look_up_west_ray_bb(Position@3)
end,
South_ray_bb_with_blocker = bitboard:exclusive_or(
South_mask_bb,
First_blocker_south_mask_bb
),
East_ray_bb_with_blocker = bitboard:exclusive_or(
East_mask_bb,
First_blocker_east_mask_bb
),
North_ray_bb_with_blocker = bitboard:exclusive_or(
North_mask_bb,
First_blocker_north_mask_bb
),
West_ray_bb_with_blocker = bitboard:exclusive_or(
West_mask_bb,
First_blocker_west_mask_bb
),
South_ray_bb = case Color of
white ->
bitboard:'and'(
South_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
East_ray_bb = case Color of
white ->
bitboard:'and'(
East_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
East_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_ray_bb = case Color of
white ->
bitboard:'and'(
North_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
West_ray_bb = case Color of
white ->
bitboard:'and'(
West_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
West_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
Rook_moves = gleam@list:fold(
[South_ray_bb, East_ray_bb, North_ray_bb, West_ray_bb],
{ok, []},
fun(Collector@1, Next) ->
Captures = case Color of
white ->
bitboard:'and'(
Next,
occupied_squares_black(
erlang:element(2, Game)
)
);
black ->
bitboard:'and'(
Next,
occupied_squares_white(
erlang:element(2, Game)
)
)
end,
Rook_simple_moves = case Color of
white ->
bitboard:exclusive_or(Next, Captures);
black ->
bitboard:exclusive_or(Next, Captures)
end,
gleam@result:'try'(
board:get_positions(Rook_simple_moves),
fun(Rook_simple_moves_positions) ->
Simple_moves = gleam@list:map(
Rook_simple_moves_positions,
fun(Dest) ->
{normal,
Queen_origin_square,
Dest,
none}
end
),
gleam@result:'try'(
board:get_positions(Captures),
fun(Captures_positions) ->
Captures@1 = gleam@list:map(
Captures_positions,
fun(Dest@1) ->
{normal,
Queen_origin_square,
Dest@1,
none}
end
),
gleam@result:'try'(
Collector@1,
fun(Collector@2) ->
Simple_moves@1 = gleam@list:append(
Collector@2,
Simple_moves
),
All_moves = gleam@list:append(
Simple_moves@1,
Captures@1
),
{ok, All_moves}
end
)
end
)
end
)
end
),
South_west_mask_bb = look_up_south_west_ray_bb(
Queen_origin_square
),
South_east_mask_bb = look_up_south_east_ray_bb(
Queen_origin_square
),
North_east_mask_bb = look_up_north_east_ray_bb(
Queen_origin_square
),
North_west_mask_bb = look_up_north_west_ray_bb(
Queen_origin_square
),
Occupied_squares_bb@1 = occupied_squares(
erlang:element(2, Game)
),
South_west_blockers_bb = bitboard:'and'(
South_west_mask_bb,
Occupied_squares_bb@1
),
South_east_blockers_bb = bitboard:'and'(
South_east_mask_bb,
Occupied_squares_bb@1
),
North_east_blockers_bb = bitboard:'and'(
North_east_mask_bb,
Occupied_squares_bb@1
),
North_west_blockers_bb = bitboard:'and'(
North_west_mask_bb,
Occupied_squares_bb@1
),
First_blocker_south_west = position:from_int(
bitboard:bitscan_backward(South_west_blockers_bb)
),
First_blocker_south_east = position:from_int(
bitboard:bitscan_backward(South_east_blockers_bb)
),
First_blocker_north_east = position:from_int(
bitboard:bitscan_forward(North_east_blockers_bb)
),
First_blocker_north_west = position:from_int(
bitboard:bitscan_forward(North_west_blockers_bb)
),
First_blocker_south_west_mask_bb = case First_blocker_south_west of
{error, _} ->
0;
{ok, Position@4} ->
look_up_south_west_ray_bb(Position@4)
end,
First_blocker_south_east_mask_bb = case First_blocker_south_east of
{error, _} ->
0;
{ok, Position@5} ->
look_up_south_east_ray_bb(Position@5)
end,
First_blocker_north_east_mask_bb = case First_blocker_north_east of
{error, _} ->
0;
{ok, Position@6} ->
look_up_north_east_ray_bb(Position@6)
end,
First_blocker_north_west_mask_bb = case First_blocker_north_west of
{error, _} ->
0;
{ok, Position@7} ->
look_up_north_west_ray_bb(Position@7)
end,
South_west_ray_bb_with_blocker = bitboard:exclusive_or(
South_west_mask_bb,
First_blocker_south_west_mask_bb
),
South_east_ray_bb_with_blocker = bitboard:exclusive_or(
South_east_mask_bb,
First_blocker_south_east_mask_bb
),
North_east_ray_bb_with_blocker = bitboard:exclusive_or(
North_east_mask_bb,
First_blocker_north_east_mask_bb
),
North_west_ray_bb_with_blocker = bitboard:exclusive_or(
North_west_mask_bb,
First_blocker_north_west_mask_bb
),
South_west_ray_bb = case Color of
white ->
bitboard:'and'(
South_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
South_east_ray_bb = case Color of
white ->
bitboard:'and'(
South_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_east_ray_bb = case Color of
white ->
bitboard:'and'(
North_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_west_ray_bb = case Color of
white ->
bitboard:'and'(
North_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
Bishop_moves = gleam@list:fold(
[South_west_ray_bb,
South_east_ray_bb,
North_east_ray_bb,
North_west_ray_bb],
{ok, []},
fun(Collector@3, Next@1) ->
Captures@2 = case Color of
white ->
bitboard:'and'(
Next@1,
occupied_squares_black(
erlang:element(2, Game)
)
);
black ->
bitboard:'and'(
Next@1,
occupied_squares_white(
erlang:element(2, Game)
)
)
end,
Rook_simple_moves@1 = case Color of
white ->
bitboard:exclusive_or(Next@1, Captures@2);
black ->
bitboard:exclusive_or(Next@1, Captures@2)
end,
gleam@result:'try'(
board:get_positions(Rook_simple_moves@1),
fun(Rook_simple_moves_positions@1) ->
Simple_moves@2 = gleam@list:map(
Rook_simple_moves_positions@1,
fun(Dest@2) ->
{normal,
Queen_origin_square,
Dest@2,
none}
end
),
gleam@result:'try'(
board:get_positions(Captures@2),
fun(Captures_positions@1) ->
Captures@3 = gleam@list:map(
Captures_positions@1,
fun(Dest@3) ->
{normal,
Queen_origin_square,
Dest@3,
none}
end
),
gleam@result:'try'(
Collector@3,
fun(Collector@4) ->
Simple_moves@3 = gleam@list:append(
Collector@4,
Simple_moves@2
),
All_moves@1 = gleam@list:append(
Simple_moves@3,
Captures@3
),
{ok, All_moves@1}
end
)
end
)
end
)
end
),
gleam@result:'try'(
Rook_moves,
fun(Rook_moves@1) ->
gleam@result:'try'(
Bishop_moves,
fun(Bishop_moves@1) ->
gleam@result:'try'(
Collector,
fun(Collector@5) ->
All_moves@2 = gleam@list:append(
gleam@list:append(
Collector@5,
Rook_moves@1
),
Bishop_moves@1
),
{ok, All_moves@2}
end
)
end
)
end
)
end
)
end
).
-spec generate_rook_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_rook_pseudo_legal_move_list(Color, Game) ->
Rook_bitboard = case Color of
white ->
erlang:element(10, erlang:element(2, Game));
black ->
erlang:element(4, erlang:element(2, Game))
end,
gleam@result:'try'(
board:get_positions(Rook_bitboard),
fun(Rook_origin_squares) ->
gleam@list:fold(
Rook_origin_squares,
{ok, []},
fun(Collector, Rook_origin_square) ->
South_mask_bb = look_up_south_ray_bb(Rook_origin_square),
East_mask_bb = look_up_east_ray_bb(Rook_origin_square),
North_mask_bb = look_up_north_ray_bb(Rook_origin_square),
West_mask_bb = look_up_west_ray_bb(Rook_origin_square),
Occupied_squares_bb = occupied_squares(
erlang:element(2, Game)
),
South_blockers_bb = bitboard:'and'(
South_mask_bb,
Occupied_squares_bb
),
East_blockers_bb = bitboard:'and'(
East_mask_bb,
Occupied_squares_bb
),
North_blockers_bb = bitboard:'and'(
North_mask_bb,
Occupied_squares_bb
),
West_blockers_bb = bitboard:'and'(
West_mask_bb,
Occupied_squares_bb
),
First_blocker_south = position:from_int(
bitboard:bitscan_backward(South_blockers_bb)
),
First_blocker_east = position:from_int(
bitboard:bitscan_forward(East_blockers_bb)
),
First_blocker_north = position:from_int(
bitboard:bitscan_forward(North_blockers_bb)
),
First_blocker_west = position:from_int(
bitboard:bitscan_backward(West_blockers_bb)
),
First_blocker_south_mask_bb = case First_blocker_south of
{error, _} ->
0;
{ok, Position} ->
look_up_south_ray_bb(Position)
end,
First_blocker_east_mask_bb = case First_blocker_east of
{error, _} ->
0;
{ok, Position@1} ->
look_up_east_ray_bb(Position@1)
end,
First_blocker_north_mask_bb = case First_blocker_north of
{error, _} ->
0;
{ok, Position@2} ->
look_up_north_ray_bb(Position@2)
end,
First_blocker_west_mask_bb = case First_blocker_west of
{error, _} ->
0;
{ok, Position@3} ->
look_up_west_ray_bb(Position@3)
end,
South_ray_bb_with_blocker = bitboard:exclusive_or(
South_mask_bb,
First_blocker_south_mask_bb
),
East_ray_bb_with_blocker = bitboard:exclusive_or(
East_mask_bb,
First_blocker_east_mask_bb
),
North_ray_bb_with_blocker = bitboard:exclusive_or(
North_mask_bb,
First_blocker_north_mask_bb
),
West_ray_bb_with_blocker = bitboard:exclusive_or(
West_mask_bb,
First_blocker_west_mask_bb
),
South_ray_bb = case Color of
white ->
bitboard:'and'(
South_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
East_ray_bb = case Color of
white ->
bitboard:'and'(
East_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
East_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_ray_bb = case Color of
white ->
bitboard:'and'(
North_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
West_ray_bb = case Color of
white ->
bitboard:'and'(
West_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
West_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
Rook_moves = gleam@list:fold(
[South_ray_bb, East_ray_bb, North_ray_bb, West_ray_bb],
{ok, []},
fun(Collector@1, Next) ->
Rook_captures = case Color of
white ->
bitboard:'and'(
Next,
occupied_squares_black(
erlang:element(2, Game)
)
);
black ->
bitboard:'and'(
Next,
occupied_squares_white(
erlang:element(2, Game)
)
)
end,
Rook_simple_moves = case Color of
white ->
bitboard:exclusive_or(Next, Rook_captures);
black ->
bitboard:exclusive_or(Next, Rook_captures)
end,
gleam@result:'try'(
board:get_positions(Rook_simple_moves),
fun(Rook_simple_moves_positions) ->
Simple_moves = gleam@list:map(
Rook_simple_moves_positions,
fun(Dest) ->
{normal,
Rook_origin_square,
Dest,
none}
end
),
gleam@result:'try'(
board:get_positions(Rook_captures),
fun(Rook_captures_positions) ->
Captures = gleam@list:map(
Rook_captures_positions,
fun(Dest@1) ->
{normal,
Rook_origin_square,
Dest@1,
none}
end
),
gleam@result:'try'(
Collector@1,
fun(Collector@2) ->
Simple_moves@1 = gleam@list:append(
Collector@2,
Simple_moves
),
All_moves = gleam@list:append(
Simple_moves@1,
Captures
),
{ok, All_moves}
end
)
end
)
end
)
end
),
gleam@result:'try'(
Rook_moves,
fun(Rook_moves@1) ->
gleam@result:'try'(
Collector,
fun(Collector@3) ->
{ok,
gleam@list:append(
Collector@3,
Rook_moves@1
)}
end
)
end
)
end
)
end
).
-spec piece_at_position(game(), position:position()) -> gleam@option:option(piece:piece()).
piece_at_position(Game, Position) ->
Position_bb_masked = bitboard:'and'(
position:to_bitboard(Position),
occupied_squares(erlang:element(2, Game))
),
Position_white_king = bitboard:'and'(
Position_bb_masked,
erlang:element(8, erlang:element(2, Game))
),
Position_white_queen = bitboard:'and'(
Position_bb_masked,
erlang:element(9, erlang:element(2, Game))
),
Position_white_rook = bitboard:'and'(
Position_bb_masked,
erlang:element(10, erlang:element(2, Game))
),
Position_white_bishop = bitboard:'and'(
Position_bb_masked,
erlang:element(11, erlang:element(2, Game))
),
Position_white_knight = bitboard:'and'(
Position_bb_masked,
erlang:element(12, erlang:element(2, Game))
),
Position_white_pawn = bitboard:'and'(
Position_bb_masked,
erlang:element(13, erlang:element(2, Game))
),
Position_black_king = bitboard:'and'(
Position_bb_masked,
erlang:element(2, erlang:element(2, Game))
),
Position_black_queen = bitboard:'and'(
Position_bb_masked,
erlang:element(3, erlang:element(2, Game))
),
Position_black_rook = bitboard:'and'(
Position_bb_masked,
erlang:element(4, erlang:element(2, Game))
),
Position_black_bishop = bitboard:'and'(
Position_bb_masked,
erlang:element(5, erlang:element(2, Game))
),
Position_black_knight = bitboard:'and'(
Position_bb_masked,
erlang:element(6, erlang:element(2, Game))
),
Position_black_pawn = bitboard:'and'(
Position_bb_masked,
erlang:element(7, erlang:element(2, Game))
),
case Position_bb_masked of
0 ->
none;
_ when Position_white_king =/= 0 ->
{some, {piece, white, king}};
_ when Position_white_queen =/= 0 ->
{some, {piece, white, queen}};
_ when Position_white_rook =/= 0 ->
{some, {piece, white, rook}};
_ when Position_white_bishop =/= 0 ->
{some, {piece, white, bishop}};
_ when Position_white_knight =/= 0 ->
{some, {piece, white, knight}};
_ when Position_white_pawn =/= 0 ->
{some, {piece, white, pawn}};
_ when Position_black_king =/= 0 ->
{some, {piece, black, king}};
_ when Position_black_queen =/= 0 ->
{some, {piece, black, queen}};
_ when Position_black_rook =/= 0 ->
{some, {piece, black, rook}};
_ when Position_black_bishop =/= 0 ->
{some, {piece, black, bishop}};
_ when Position_black_knight =/= 0 ->
{some, {piece, black, knight}};
_ when Position_black_pawn =/= 0 ->
{some, {piece, black, pawn}};
_ ->
erlang:error(#{gleam_error => panic,
message => <<"panic expression evaluated"/utf8>>,
module => <<"game"/utf8>>,
function => <<"piece_at_position"/utf8>>,
line => 2583})
end.
-spec apply_move_raw(game(), move:move()) -> {ok, game()} | {error, binary()}.
apply_move_raw(Game, Move) ->
case Move of
{normal, From, To, Promo_piece} ->
gleam@result:'try'(
case board:get_piece_at_position(erlang:element(2, Game), From) of
{some, Piece} ->
{ok, Piece};
none ->
{error, <<"No piece at from position"/utf8>>}
end,
fun(Moving_piece) ->
Captured_piece = piece_at_position(Game, To),
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
From
),
fun(New_board) ->
New_game_state = erlang:setelement(
2,
Game,
New_board
),
gleam@result:'try'(case Captured_piece of
none ->
{ok, New_game_state};
{some, _} ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(
2,
New_game_state
),
To
),
fun(New_board@1) ->
{ok,
erlang:setelement(
2,
New_game_state,
New_board@1
)}
end
)
end, fun(New_game_state@1) ->
New_game_state@2 = case Promo_piece of
none ->
erlang:setelement(
2,
New_game_state@1,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@1
),
To,
Moving_piece
)
);
{some, Promo_piece@1} ->
erlang:setelement(
2,
New_game_state@1,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@1
),
To,
Promo_piece@1
)
)
end,
New_ply = erlang:element(
6,
New_game_state@2
)
+ 1,
New_white_king_castle = case erlang:element(
3,
Game
) of
white ->
case erlang:element(7, Game) of
yes ->
case From of
{position, e, one} ->
{no, New_ply};
{position, h, one} ->
{no, New_ply};
_ ->
yes
end;
{no, Some_ply} ->
{no, Some_ply}
end;
black ->
erlang:element(7, Game)
end,
New_white_queen_castle = case erlang:element(
3,
Game
) of
white ->
case erlang:element(8, Game) of
yes ->
case From of
{position, e, one} ->
{no, New_ply};
{position, a, one} ->
{no, New_ply};
_ ->
yes
end;
{no, Some_ply@1} ->
{no, Some_ply@1}
end;
black ->
erlang:element(8, Game)
end,
New_black_king_castle = case erlang:element(
3,
Game
) of
white ->
erlang:element(9, Game);
black ->
case erlang:element(9, Game) of
yes ->
case From of
{position, e, eight} ->
{no, New_ply};
{position, h, eight} ->
{no, New_ply};
_ ->
yes
end;
{no, Some_ply@2} ->
{no, Some_ply@2}
end
end,
New_black_queen_castle = case erlang:element(
3,
Game
) of
white ->
erlang:element(10, Game);
black ->
case erlang:element(10, Game) of
yes ->
case From of
{position, e, eight} ->
{no, New_ply};
{position, a, eight} ->
{no, New_ply};
_ ->
yes
end;
{no, Some_ply@3} ->
{no, Some_ply@3}
end
end,
New_turn = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
Move_with_capture = {move_with_capture,
Move,
Captured_piece},
New_history = [Move_with_capture |
erlang:element(4, Game)],
New_en_passant = case Moving_piece of
{piece, Color, pawn} ->
case Color of
white ->
case From of
{position, _, two} ->
case To of
{position,
_,
four} ->
{some,
{position,
erlang:element(
2,
From
),
three}};
_ ->
none
end;
_ ->
none
end;
black ->
case From of
{position, _, seven} ->
case To of
{position,
_,
five} ->
{some,
{position,
erlang:element(
2,
From
),
six}};
_ ->
none
end;
_ ->
none
end
end;
_ ->
none
end,
New_game_state@3 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@2,
New_turn
),
New_history
),
New_ply
),
New_white_king_castle
),
New_white_queen_castle
),
New_black_king_castle
),
New_black_queen_castle
),
New_en_passant
),
{ok, New_game_state@3}
end)
end
)
end
);
{castle, From@1, To@1} ->
gleam@result:'try'(
board:remove_piece_at_position(erlang:element(2, Game), From@1),
fun(New_board@2) ->
New_game_state@4 = erlang:setelement(2, Game, New_board@2),
New_game_state@5 = erlang:setelement(
2,
New_game_state@4,
board:set_piece_at_position(
erlang:element(2, New_game_state@4),
To@1,
{piece, erlang:element(3, New_game_state@4), king}
)
),
gleam@result:'try'(case To@1 of
{position, g, one} ->
{ok, {position, f, one}};
{position, g, eight} ->
{ok, {position, f, eight}};
{position, c, one} ->
{ok, {position, d, one}};
{position, c, eight} ->
{ok, {position, d, eight}};
_ ->
{error, <<"Invalid castle move"/utf8>>}
end, fun(Rook_castling_target_square) ->
New_turn@1 = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
New_game_state@6 = erlang:setelement(
2,
New_game_state@5,
board:set_piece_at_position(
erlang:element(2, New_game_state@5),
Rook_castling_target_square,
{piece, erlang:element(3, Game), rook}
)
),
gleam@result:'try'(case To@1 of
{position, g, one} ->
{ok, {position, h, one}};
{position, g, eight} ->
{ok, {position, h, eight}};
{position, c, one} ->
{ok, {position, a, one}};
{position, c, eight} ->
{ok, {position, a, eight}};
_ ->
{error, <<"Invalid castle move"/utf8>>}
end, fun(Rook_castling_origin_square) ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, New_game_state@6),
Rook_castling_origin_square
),
fun(New_board@3) ->
New_game_state@7 = erlang:setelement(
2,
New_game_state@6,
New_board@3
),
New_ply@1 = erlang:element(
6,
New_game_state@7
)
+ 1,
gleam@result:'try'(
case erlang:element(3, Game) of
white ->
{ok,
{{no, New_ply@1},
{no, New_ply@1},
erlang:element(
9,
Game
),
erlang:element(
10,
Game
)}};
black ->
{ok,
{erlang:element(
7,
Game
),
erlang:element(
8,
Game
),
{no, New_ply@1},
{no, New_ply@1}}}
end,
fun(_use0) ->
{New_white_king_castle@1,
New_white_queen_castle@1,
New_black_king_castle@1,
New_black_queen_castle@1} = _use0,
Move_with_capture@1 = {move_with_capture,
Move,
none},
New_history@1 = [Move_with_capture@1 |
erlang:element(4, Game)],
New_en_passant@1 = none,
New_game_state@8 = erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
11,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@7,
New_turn@1
),
New_history@1
),
New_ply@1
),
New_en_passant@1
),
New_white_king_castle@1
),
New_white_queen_castle@1
),
New_black_king_castle@1
),
New_black_queen_castle@1
),
{ok, New_game_state@8}
end
)
end
)
end)
end)
end
);
{en_passant, From@2, To@2} ->
New_game_state@9 = erlang:setelement(
2,
Game,
board:set_piece_at_position(
erlang:element(2, Game),
To@2,
{piece, erlang:element(3, Game), pawn}
)
),
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, New_game_state@9),
From@2
),
fun(New_board@4) ->
New_game_state@10 = erlang:setelement(
2,
New_game_state@9,
New_board@4
),
gleam@result:'try'(case To@2 of
{position, a, three} ->
{ok, {position, a, four}};
{position, a, six} ->
{ok, {position, a, five}};
{position, b, three} ->
{ok, {position, b, four}};
{position, b, six} ->
{ok, {position, b, five}};
{position, c, three} ->
{ok, {position, c, four}};
{position, c, six} ->
{ok, {position, c, five}};
{position, d, three} ->
{ok, {position, d, four}};
{position, d, six} ->
{ok, {position, d, five}};
{position, e, three} ->
{ok, {position, e, four}};
{position, e, six} ->
{ok, {position, e, five}};
{position, f, three} ->
{ok, {position, f, four}};
{position, f, six} ->
{ok, {position, f, five}};
{position, g, three} ->
{ok, {position, g, four}};
{position, g, six} ->
{ok, {position, g, five}};
{position, h, three} ->
{ok, {position, h, four}};
{position, h, six} ->
{ok, {position, h, five}};
_ ->
{error, <<"Invalid en passant move"/utf8>>}
end, fun(Captured_pawn_square) ->
gleam@result:'try'(
case board:remove_piece_at_position(
erlang:element(2, New_game_state@10),
Captured_pawn_square
) of
{ok, New_board@5} ->
{ok, New_board@5};
{error, _} ->
{error,
<<"Invalid en passant move"/utf8>>}
end,
fun(New_board@6) ->
New_ply@2 = erlang:element(
6,
New_game_state@10
)
+ 1,
New_turn@2 = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
New_game_state@11 = erlang:setelement(
2,
New_game_state@10,
New_board@6
),
Move_with_capture@2 = {move_with_capture,
Move,
{some, {piece, New_turn@2, pawn}}},
New_history@2 = [Move_with_capture@2 |
erlang:element(4, Game)],
New_en_passant@2 = none,
New_game_state@12 = erlang:setelement(
11,
erlang:setelement(
6,
erlang:setelement(
3,
erlang:setelement(
4,
New_game_state@11,
New_history@2
),
New_turn@2
),
New_ply@2
),
New_en_passant@2
),
{ok, New_game_state@12}
end
)
end)
end
)
end.
-spec generate_bishop_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_bishop_pseudo_legal_move_list(Color, Game) ->
Bishop_bitboard = case Color of
white ->
erlang:element(11, erlang:element(2, Game));
black ->
erlang:element(5, erlang:element(2, Game))
end,
gleam@result:'try'(
board:get_positions(Bishop_bitboard),
fun(Bishop_origin_squares) ->
gleam@list:fold(
Bishop_origin_squares,
{ok, []},
fun(Collector, Bishop_origin_square) ->
South_west_mask_bb = look_up_south_west_ray_bb(
Bishop_origin_square
),
South_east_mask_bb = look_up_south_east_ray_bb(
Bishop_origin_square
),
North_east_mask_bb = look_up_north_east_ray_bb(
Bishop_origin_square
),
North_west_mask_bb = look_up_north_west_ray_bb(
Bishop_origin_square
),
Occupied_squares_bb = occupied_squares(
erlang:element(2, Game)
),
South_west_blockers_bb = bitboard:'and'(
South_west_mask_bb,
Occupied_squares_bb
),
South_east_blockers_bb = bitboard:'and'(
South_east_mask_bb,
Occupied_squares_bb
),
North_east_blockers_bb = bitboard:'and'(
North_east_mask_bb,
Occupied_squares_bb
),
North_west_blockers_bb = bitboard:'and'(
North_west_mask_bb,
Occupied_squares_bb
),
First_blocker_south_west = position:from_int(
bitboard:bitscan_backward(South_west_blockers_bb)
),
First_blocker_south_east = position:from_int(
bitboard:bitscan_backward(South_east_blockers_bb)
),
First_blocker_north_east = position:from_int(
bitboard:bitscan_forward(North_east_blockers_bb)
),
First_blocker_north_west = position:from_int(
bitboard:bitscan_forward(North_west_blockers_bb)
),
First_blocker_south_west_mask_bb = case First_blocker_south_west of
{error, _} ->
0;
{ok, Position} ->
look_up_south_west_ray_bb(Position)
end,
First_blocker_south_east_mask_bb = case First_blocker_south_east of
{error, _} ->
0;
{ok, Position@1} ->
look_up_south_east_ray_bb(Position@1)
end,
First_blocker_north_east_mask_bb = case First_blocker_north_east of
{error, _} ->
0;
{ok, Position@2} ->
look_up_north_east_ray_bb(Position@2)
end,
First_blocker_north_west_mask_bb = case First_blocker_north_west of
{error, _} ->
0;
{ok, Position@3} ->
look_up_north_west_ray_bb(Position@3)
end,
South_west_ray_bb_with_blocker = bitboard:exclusive_or(
South_west_mask_bb,
First_blocker_south_west_mask_bb
),
South_east_ray_bb_with_blocker = bitboard:exclusive_or(
South_east_mask_bb,
First_blocker_south_east_mask_bb
),
North_east_ray_bb_with_blocker = bitboard:exclusive_or(
North_east_mask_bb,
First_blocker_north_east_mask_bb
),
North_west_ray_bb_with_blocker = bitboard:exclusive_or(
North_west_mask_bb,
First_blocker_north_west_mask_bb
),
South_west_ray_bb = case Color of
white ->
bitboard:'and'(
South_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
South_east_ray_bb = case Color of
white ->
bitboard:'and'(
South_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
South_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_east_ray_bb = case Color of
white ->
bitboard:'and'(
North_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_east_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
North_west_ray_bb = case Color of
white ->
bitboard:'and'(
North_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_white(
erlang:element(2, Game)
)
)
);
black ->
bitboard:'and'(
North_west_ray_bb_with_blocker,
bitboard:'not'(
occupied_squares_black(
erlang:element(2, Game)
)
)
)
end,
Bishop_moves = gleam@list:fold(
[South_west_ray_bb,
South_east_ray_bb,
North_east_ray_bb,
North_west_ray_bb],
{ok, []},
fun(Collector@1, Next) ->
Captures = case Color of
white ->
bitboard:'and'(
Next,
occupied_squares_black(
erlang:element(2, Game)
)
);
black ->
bitboard:'and'(
Next,
occupied_squares_white(
erlang:element(2, Game)
)
)
end,
Rook_simple_moves = case Color of
white ->
bitboard:exclusive_or(Next, Captures);
black ->
bitboard:exclusive_or(Next, Captures)
end,
gleam@result:'try'(
board:get_positions(Rook_simple_moves),
fun(Rook_simple_moves_positions) ->
gleam@result:'try'(
board:get_positions(Captures),
fun(Captures_positions) ->
Simple_moves = gleam@list:map(
Rook_simple_moves_positions,
fun(Dest) ->
{normal,
Bishop_origin_square,
Dest,
none}
end
),
Captures@1 = gleam@list:map(
Captures_positions,
fun(Dest@1) ->
{normal,
Bishop_origin_square,
Dest@1,
none}
end
),
gleam@result:'try'(
Collector@1,
fun(Collector@2) ->
Simple_moves@1 = gleam@list:append(
Collector@2,
Simple_moves
),
All_moves = gleam@list:append(
Simple_moves@1,
Captures@1
),
{ok, All_moves}
end
)
end
)
end
)
end
),
gleam@result:'try'(
Bishop_moves,
fun(Bishop_moves@1) ->
gleam@result:'try'(
Collector,
fun(Collector@3) ->
{ok,
gleam@list:append(
Collector@3,
Bishop_moves@1
)}
end
)
end
)
end
)
end
).
-spec generate_pawn_non_capture_move_bitboard(color:color(), game()) -> integer().
generate_pawn_non_capture_move_bitboard(Color, Game) ->
case Color of
white ->
White_pawn_target_squares = bitboard:shift_left(
erlang:element(13, erlang:element(2, Game)),
8
),
List_of_enemy_piece_bitboards = [erlang:element(
2,
erlang:element(2, Game)
),
erlang:element(3, erlang:element(2, Game)),
erlang:element(4, erlang:element(2, Game)),
erlang:element(5, erlang:element(2, Game)),
erlang:element(6, erlang:element(2, Game)),
erlang:element(7, erlang:element(2, Game))],
Occupied_squares_white = occupied_squares_white(
erlang:element(2, Game)
),
Enemy_pieces = gleam@list:fold(
List_of_enemy_piece_bitboards,
0,
fun(Collector, Next) -> bitboard:'or'(Collector, Next) end
),
Moves = bitboard:exclusive_or(
White_pawn_target_squares,
Enemy_pieces
),
Moves@1 = bitboard:'and'(Moves, White_pawn_target_squares),
Moves@2 = bitboard:'and'(
Moves@1,
bitboard:'not'(Occupied_squares_white)
),
Moves@2;
black ->
Black_pawn_target_squares = bitboard:shift_right(
erlang:element(7, erlang:element(2, Game)),
8
),
List_of_enemy_piece_bitboards@1 = [erlang:element(
8,
erlang:element(2, Game)
),
erlang:element(9, erlang:element(2, Game)),
erlang:element(10, erlang:element(2, Game)),
erlang:element(11, erlang:element(2, Game)),
erlang:element(12, erlang:element(2, Game)),
erlang:element(13, erlang:element(2, Game))],
Occupied_squares_black = occupied_squares_black(
erlang:element(2, Game)
),
Enemy_pieces@1 = gleam@list:fold(
List_of_enemy_piece_bitboards@1,
0,
fun(Collector@1, Next@1) ->
bitboard:'or'(Collector@1, Next@1)
end
),
Moves@3 = bitboard:exclusive_or(
Black_pawn_target_squares,
Enemy_pieces@1
),
Moves@4 = bitboard:'and'(Moves@3, Black_pawn_target_squares),
Moves@5 = bitboard:'and'(
Moves@4,
bitboard:'not'(Occupied_squares_black)
),
Moves@5
end.
-spec bitboard_repr_to_map_repr(board:board_bb()) -> {ok,
gleam@dict:dict(position:position(), gleam@option:option(piece:piece()))} |
{error, binary()}.
bitboard_repr_to_map_repr(Board) ->
White_king_bitboard = erlang:element(8, Board),
White_queen_bitboard = erlang:element(9, Board),
White_rook_bitboard = erlang:element(10, Board),
White_bishop_bitboard = erlang:element(11, Board),
White_knight_bitboard = erlang:element(12, Board),
White_pawns_bitboard = erlang:element(13, Board),
Black_king_bitboard = erlang:element(2, Board),
Black_queen_bitboard = erlang:element(3, Board),
Black_rook_bitboard = erlang:element(4, Board),
Black_bishop_bitboard = erlang:element(5, Board),
Black_knight_bitboard = erlang:element(6, Board),
Black_pawns_bitboard = erlang:element(7, Board),
Board_map = maps:from_list(
[{{position, a, one}, none},
{{position, b, one}, none},
{{position, c, one}, none},
{{position, d, one}, none},
{{position, e, one}, none},
{{position, f, one}, none},
{{position, g, one}, none},
{{position, h, one}, none},
{{position, a, two}, none},
{{position, b, two}, none},
{{position, c, two}, none},
{{position, d, two}, none},
{{position, e, two}, none},
{{position, f, two}, none},
{{position, g, two}, none},
{{position, h, two}, none},
{{position, a, three}, none},
{{position, b, three}, none},
{{position, c, three}, none},
{{position, d, three}, none},
{{position, e, three}, none},
{{position, f, three}, none},
{{position, g, three}, none},
{{position, h, three}, none},
{{position, a, four}, none},
{{position, b, four}, none},
{{position, c, four}, none},
{{position, d, four}, none},
{{position, e, four}, none},
{{position, f, four}, none},
{{position, g, four}, none},
{{position, h, four}, none},
{{position, a, five}, none},
{{position, b, five}, none},
{{position, c, five}, none},
{{position, d, five}, none},
{{position, e, five}, none},
{{position, f, five}, none},
{{position, g, five}, none},
{{position, h, five}, none},
{{position, a, six}, none},
{{position, b, six}, none},
{{position, c, six}, none},
{{position, d, six}, none},
{{position, e, six}, none},
{{position, f, six}, none},
{{position, g, six}, none},
{{position, h, six}, none},
{{position, a, seven}, none},
{{position, b, seven}, none},
{{position, c, seven}, none},
{{position, d, seven}, none},
{{position, e, seven}, none},
{{position, f, seven}, none},
{{position, g, seven}, none},
{{position, h, seven}, none},
{{position, a, eight}, none},
{{position, b, eight}, none},
{{position, c, eight}, none},
{{position, d, eight}, none},
{{position, e, eight}, none},
{{position, f, eight}, none},
{{position, g, eight}, none},
{{position, h, eight}, none}]
),
gleam@result:'try'(
board:get_positions(White_king_bitboard),
fun(White_king_positions) ->
gleam@result:'try'(
board:get_positions(White_queen_bitboard),
fun(White_queen_positions) ->
gleam@result:'try'(
board:get_positions(White_rook_bitboard),
fun(White_rook_positions) ->
gleam@result:'try'(
board:get_positions(White_bishop_bitboard),
fun(White_bishop_positions) ->
gleam@result:'try'(
board:get_positions(
White_knight_bitboard
),
fun(White_knight_positions) ->
gleam@result:'try'(
board:get_positions(
White_pawns_bitboard
),
fun(White_pawns_positions) ->
gleam@result:'try'(
board:get_positions(
Black_king_bitboard
),
fun(
Black_king_positions
) ->
gleam@result:'try'(
board:get_positions(
Black_queen_bitboard
),
fun(
Black_queen_positions
) ->
gleam@result:'try'(
board:get_positions(
Black_rook_bitboard
),
fun(
Black_rook_positions
) ->
gleam@result:'try'(
board:get_positions(
Black_bishop_bitboard
),
fun(
Black_bishop_positions
) ->
gleam@result:'try'(
board:get_positions(
Black_knight_bitboard
),
fun(
Black_knight_positions
) ->
gleam@result:'try'(
board:get_positions(
Black_pawns_bitboard
),
fun(
Black_pawns_positions
) ->
Board_map@2 = gleam@list:fold(
White_king_positions,
Board_map,
fun(
Board_map@1,
Position
) ->
gleam@dict:insert(
Board_map@1,
Position,
{some,
{piece,
white,
king}}
)
end
),
Board_map@4 = gleam@list:fold(
White_queen_positions,
Board_map@2,
fun(
Board_map@3,
Position@1
) ->
gleam@dict:insert(
Board_map@3,
Position@1,
{some,
{piece,
white,
queen}}
)
end
),
Board_map@6 = gleam@list:fold(
White_rook_positions,
Board_map@4,
fun(
Board_map@5,
Position@2
) ->
gleam@dict:insert(
Board_map@5,
Position@2,
{some,
{piece,
white,
rook}}
)
end
),
Board_map@8 = gleam@list:fold(
White_bishop_positions,
Board_map@6,
fun(
Board_map@7,
Position@3
) ->
gleam@dict:insert(
Board_map@7,
Position@3,
{some,
{piece,
white,
bishop}}
)
end
),
Board_map@10 = gleam@list:fold(
White_knight_positions,
Board_map@8,
fun(
Board_map@9,
Position@4
) ->
gleam@dict:insert(
Board_map@9,
Position@4,
{some,
{piece,
white,
knight}}
)
end
),
Board_map@12 = gleam@list:fold(
White_pawns_positions,
Board_map@10,
fun(
Board_map@11,
Position@5
) ->
gleam@dict:insert(
Board_map@11,
Position@5,
{some,
{piece,
white,
pawn}}
)
end
),
Board_map@14 = gleam@list:fold(
Black_king_positions,
Board_map@12,
fun(
Board_map@13,
Position@6
) ->
gleam@dict:insert(
Board_map@13,
Position@6,
{some,
{piece,
black,
king}}
)
end
),
Board_map@16 = gleam@list:fold(
Black_queen_positions,
Board_map@14,
fun(
Board_map@15,
Position@7
) ->
gleam@dict:insert(
Board_map@15,
Position@7,
{some,
{piece,
black,
queen}}
)
end
),
Board_map@18 = gleam@list:fold(
Black_rook_positions,
Board_map@16,
fun(
Board_map@17,
Position@8
) ->
gleam@dict:insert(
Board_map@17,
Position@8,
{some,
{piece,
black,
rook}}
)
end
),
Board_map@20 = gleam@list:fold(
Black_bishop_positions,
Board_map@18,
fun(
Board_map@19,
Position@9
) ->
gleam@dict:insert(
Board_map@19,
Position@9,
{some,
{piece,
black,
bishop}}
)
end
),
Board_map@22 = gleam@list:fold(
Black_knight_positions,
Board_map@20,
fun(
Board_map@21,
Position@10
) ->
gleam@dict:insert(
Board_map@21,
Position@10,
{some,
{piece,
black,
knight}}
)
end
),
Board_map@24 = gleam@list:fold(
Black_pawns_positions,
Board_map@22,
fun(
Board_map@23,
Position@11
) ->
gleam@dict:insert(
Board_map@23,
Position@11,
{some,
{piece,
black,
pawn}}
)
end
),
{ok,
Board_map@24}
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
).
-spec disable_status(game()) -> game().
disable_status(Game) ->
erlang:setelement(5, Game, none).
-spec undo_move(game()) -> {ok, game()} | {error, binary()}.
undo_move(Game) ->
case erlang:element(5, Game) of
{some, {in_progress, _, _}} ->
case erlang:element(4, Game) of
[] ->
{ok, Game};
[Move | Rest] ->
case Move of
{move_with_capture,
{normal, From, To, Promo_piece},
Captured_piece} ->
Moving_piece = case board:get_piece_at_position(
erlang:element(2, Game),
To
) of
none ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4409});
{some, Piece} ->
Piece
end,
Moving_piece@1 = case Promo_piece of
none ->
Moving_piece;
{some, _} ->
{piece,
erlang:element(2, Moving_piece),
pawn}
end,
New_turn = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
gleam@result:'try'(case Captured_piece of
none ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To
),
fun(New_board) ->
{ok,
erlang:setelement(
2,
Game,
New_board
)}
end
);
{some, Piece@1} ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To
),
fun(New_board@1) ->
New_board@2 = board:set_piece_at_position(
New_board@1,
To,
Piece@1
),
{ok,
erlang:setelement(
2,
Game,
New_board@2
)}
end
)
end, fun(New_game_state) ->
New_board@3 = board:set_piece_at_position(
erlang:element(2, New_game_state),
From,
Moving_piece@1
),
New_game_state@1 = erlang:setelement(
2,
New_game_state,
New_board@3
),
New_ply = erlang:element(6, Game) - 1,
New_white_kingside_castle = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply} ->
case Ply =:= erlang:element(6, Game) of
true ->
yes;
false ->
{no, Ply}
end
end,
New_white_queenside_castle = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@1} ->
case Ply@1 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@1}
end
end,
New_black_kingside_castle = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@2} ->
case Ply@2 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@2}
end
end,
New_black_queenside_castle = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@3} ->
case Ply@3 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@3}
end
end,
New_history = Rest,
New_en_passant = case Rest of
[] ->
none;
[Move@1] ->
case Move@1 of
{move_with_capture,
{normal,
{position, _, two},
{position, File, four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@2 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File, four}
) of
{some, Piece@2} ->
Piece@2;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4527}
)
end,
case Moving_piece@2 of
{piece, _, pawn} ->
{some,
{position,
File,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position, _, seven},
{position, File@1, five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@3 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File@1, five}
) of
{some, Piece@3} ->
Piece@3;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move:Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4552}
)
end,
case Moving_piece@3 of
{piece, _, pawn} ->
{some,
{position,
File@1,
six}};
_ ->
none
end;
_ ->
none
end;
[Move@1 | _] ->
case Move@1 of
{move_with_capture,
{normal,
{position, _, two},
{position, File, four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@2 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File, four}
) of
{some, Piece@2} ->
Piece@2;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4527}
)
end,
case Moving_piece@2 of
{piece, _, pawn} ->
{some,
{position,
File,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position, _, seven},
{position, File@1, five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@3 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File@1, five}
) of
{some, Piece@3} ->
Piece@3;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move:Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4552}
)
end,
case Moving_piece@3 of
{piece, _, pawn} ->
{some,
{position,
File@1,
six}};
_ ->
none
end;
_ ->
none
end
end,
New_status = case erlang:element(5, Game) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule,
Threefold_repetition_rule}} ->
New_fifty_move_rule = case Fifty_move_rule of
0 ->
0;
_ ->
Fifty_move_rule - 1
end,
Threefold_position = {three_fold_position,
erlang:element(3, Game),
erlang:element(2, Game),
erlang:element(11, Game),
erlang:element(7, Game),
erlang:element(8, Game),
erlang:element(9, Game),
erlang:element(10, Game)},
New_threefold_repetition_rule = case gleam@dict:get(
Threefold_repetition_rule,
Threefold_position
) of
{error, nil} ->
Threefold_repetition_rule;
{ok, 0} ->
gleam@dict:delete(
Threefold_repetition_rule,
Threefold_position
);
{ok, 1} ->
gleam@dict:delete(
Threefold_repetition_rule,
Threefold_position
);
{ok, Count} ->
gleam@dict:insert(
Threefold_repetition_rule,
Threefold_position,
Count - 1
)
end,
{some,
{in_progress,
New_fifty_move_rule,
New_threefold_repetition_rule}};
{some, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Normal Move: trying to undo a move in a finished game is not possible"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4604})
end,
New_game_state@2 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@1,
New_turn
),
New_history
),
New_ply
),
New_status
),
New_white_kingside_castle
),
New_white_queenside_castle
),
New_black_kingside_castle
),
New_black_queenside_castle
),
New_en_passant
),
{ok, New_game_state@2}
end);
{move_with_capture, {castle, From@1, To@1}, _} ->
Rook_castling_target_square = case To@1 of
{position, g, one} ->
{position, f, one};
{position, g, eight} ->
{position, f, eight};
{position, c, one} ->
{position, d, one};
{position, c, eight} ->
{position, d, eight};
_ ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Castle Move: Invalid castle move"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4636})
end,
gleam@result:'try'(
case board:remove_piece_at_position(
erlang:element(2, Game),
Rook_castling_target_square
) of
{ok, Board} ->
{ok, Board};
{error, _} ->
{error,
<<"Undoing Castle Move: Could not remove piece at position"/utf8>>}
end,
fun(New_board@4) ->
New_game_state@3 = erlang:setelement(
2,
Game,
New_board@4
),
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, New_game_state@3),
To@1
),
fun(New_board@5) ->
New_game_state@4 = erlang:setelement(
2,
New_game_state@3,
New_board@5
),
Rook_castling_origin_square = case To@1 of
{position, g, one} ->
{position, h, one};
{position, g, eight} ->
{position, h, eight};
{position, c, one} ->
{position, a, one};
{position, c, eight} ->
{position, a, eight};
_ ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: Invalid castle move"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4668}
)
end,
New_turn@1 = (case erlang:element(
3,
New_game_state@4
) of
white ->
black;
black ->
white
end),
New_game_state@5 = erlang:setelement(
2,
New_game_state@4,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@4
),
From@1,
{piece, New_turn@1, king}
)
),
New_game_state@6 = erlang:setelement(
2,
New_game_state@5,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@5
),
Rook_castling_origin_square,
{piece, New_turn@1, rook}
)
),
New_ply@1 = erlang:element(6, Game)
- 1,
New_white_kingside_castle@1 = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply@4} ->
case Ply@4 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@4}
end
end,
New_white_queenside_castle@1 = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@5} ->
case Ply@5 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@5}
end
end,
New_black_kingside_castle@1 = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@6} ->
case Ply@6 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@6}
end
end,
New_black_queenside_castle@1 = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@7} ->
case Ply@7 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@7}
end
end,
New_history@1 = Rest,
New_en_passant@1 = case Rest of
[] ->
none;
[Move@2] ->
case Move@2 of
{move_with_capture,
{normal,
{position,
_,
two},
{position,
File@2,
four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@4 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@2,
four}
) of
{some, Piece@4} ->
Piece@4;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 1"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4767}
)
end,
case Moving_piece@4 of
{piece, _, pawn} ->
{some,
{position,
File@2,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position,
_,
seven},
{position,
File@3,
five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@5 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@3,
five}
) of
{some, Piece@5} ->
Piece@5;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 2"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4792}
)
end,
case Moving_piece@5 of
{piece, _, pawn} ->
{some,
{position,
File@3,
six}};
_ ->
none
end;
_ ->
none
end;
[Move@2 | _] ->
case Move@2 of
{move_with_capture,
{normal,
{position,
_,
two},
{position,
File@2,
four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@4 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@2,
four}
) of
{some, Piece@4} ->
Piece@4;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 1"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4767}
)
end,
case Moving_piece@4 of
{piece, _, pawn} ->
{some,
{position,
File@2,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position,
_,
seven},
{position,
File@3,
five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@5 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@3,
five}
) of
{some, Piece@5} ->
Piece@5;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 2"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4792}
)
end,
case Moving_piece@5 of
{piece, _, pawn} ->
{some,
{position,
File@3,
six}};
_ ->
none
end;
_ ->
none
end
end,
New_status@1 = case erlang:element(
5,
Game
) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule@1,
Threefold_repetition_rule@1}} ->
case Fifty_move_rule@1 of
0 ->
{some,
{in_progress,
0,
Threefold_repetition_rule@1}};
_ ->
{some,
{in_progress,
Fifty_move_rule@1
- 1,
Threefold_repetition_rule@1}}
end;
{some, _} ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: Trying to undo a move in a finished game"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4820}
)
end,
New_game_state@7 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@6,
New_turn@1
),
New_history@1
),
New_ply@1
),
New_status@1
),
New_white_kingside_castle@1
),
New_white_queenside_castle@1
),
New_black_kingside_castle@1
),
New_black_queenside_castle@1
),
New_en_passant@1
),
{ok, New_game_state@7}
end
)
end
);
{move_with_capture, {en_passant, From@2, To@2}, _} ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To@2
),
fun(New_board@6) ->
New_game_state@8 = erlang:setelement(
2,
Game,
New_board@6
),
New_game_state@9 = case erlang:element(
3,
Game
) of
black ->
erlang:setelement(
2,
New_game_state@8,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@8
),
From@2,
{piece, white, pawn}
)
);
white ->
erlang:setelement(
2,
New_game_state@8,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@8
),
From@2,
{piece, black, pawn}
)
)
end,
New_game_state@10 = case erlang:element(
3,
Game
) of
black ->
erlang:setelement(
2,
New_game_state@9,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@9
),
{position,
erlang:element(2, To@2),
five},
{piece, black, pawn}
)
);
white ->
erlang:setelement(
2,
New_game_state@9,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@9
),
{position,
erlang:element(2, To@2),
four},
{piece, white, pawn}
)
)
end,
New_ply@2 = erlang:element(6, Game) - 1,
New_white_kingside_castle@2 = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply@8} ->
case Ply@8 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@8}
end
end,
New_white_queenside_castle@2 = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@9} ->
case Ply@9 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@9}
end
end,
New_black_kingside_castle@2 = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@10} ->
case Ply@10 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@10}
end
end,
New_black_queenside_castle@2 = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@11} ->
case Ply@11 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@11}
end
end,
New_turn@2 = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
New_history@2 = Rest,
New_en_passant@2 = To@2,
New_status@2 = case erlang:element(5, Game) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule@2,
Threefold_repetition_rule@2}} ->
case Fifty_move_rule@2 of
0 ->
{some,
{in_progress,
0,
Threefold_repetition_rule@2}};
_ ->
{some,
{in_progress,
Fifty_move_rule@2 - 1,
Threefold_repetition_rule@2}}
end;
{some, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing En Passant Move: Trying to undo a move in a finished game"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4962})
end,
New_game_state@11 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@10,
New_turn@2
),
New_history@2
),
New_ply@2
),
New_status@2
),
New_white_kingside_castle@2
),
New_white_queenside_castle@2
),
New_black_kingside_castle@2
),
New_black_queenside_castle@2
),
{some, New_en_passant@2}
),
{ok, New_game_state@11}
end
)
end
end;
none ->
case erlang:element(4, Game) of
[] ->
{ok, Game};
[Move | Rest] ->
case Move of
{move_with_capture,
{normal, From, To, Promo_piece},
Captured_piece} ->
Moving_piece = case board:get_piece_at_position(
erlang:element(2, Game),
To
) of
none ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4409});
{some, Piece} ->
Piece
end,
Moving_piece@1 = case Promo_piece of
none ->
Moving_piece;
{some, _} ->
{piece,
erlang:element(2, Moving_piece),
pawn}
end,
New_turn = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
gleam@result:'try'(case Captured_piece of
none ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To
),
fun(New_board) ->
{ok,
erlang:setelement(
2,
Game,
New_board
)}
end
);
{some, Piece@1} ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To
),
fun(New_board@1) ->
New_board@2 = board:set_piece_at_position(
New_board@1,
To,
Piece@1
),
{ok,
erlang:setelement(
2,
Game,
New_board@2
)}
end
)
end, fun(New_game_state) ->
New_board@3 = board:set_piece_at_position(
erlang:element(2, New_game_state),
From,
Moving_piece@1
),
New_game_state@1 = erlang:setelement(
2,
New_game_state,
New_board@3
),
New_ply = erlang:element(6, Game) - 1,
New_white_kingside_castle = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply} ->
case Ply =:= erlang:element(6, Game) of
true ->
yes;
false ->
{no, Ply}
end
end,
New_white_queenside_castle = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@1} ->
case Ply@1 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@1}
end
end,
New_black_kingside_castle = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@2} ->
case Ply@2 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@2}
end
end,
New_black_queenside_castle = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@3} ->
case Ply@3 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@3}
end
end,
New_history = Rest,
New_en_passant = case Rest of
[] ->
none;
[Move@1] ->
case Move@1 of
{move_with_capture,
{normal,
{position, _, two},
{position, File, four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@2 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File, four}
) of
{some, Piece@2} ->
Piece@2;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4527}
)
end,
case Moving_piece@2 of
{piece, _, pawn} ->
{some,
{position,
File,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position, _, seven},
{position, File@1, five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@3 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File@1, five}
) of
{some, Piece@3} ->
Piece@3;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move:Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4552}
)
end,
case Moving_piece@3 of
{piece, _, pawn} ->
{some,
{position,
File@1,
six}};
_ ->
none
end;
_ ->
none
end;
[Move@1 | _] ->
case Move@1 of
{move_with_capture,
{normal,
{position, _, two},
{position, File, four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@2 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File, four}
) of
{some, Piece@2} ->
Piece@2;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move: Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4527}
)
end,
case Moving_piece@2 of
{piece, _, pawn} ->
{some,
{position,
File,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position, _, seven},
{position, File@1, five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@3 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@1
),
{position, File@1, five}
) of
{some, Piece@3} ->
Piece@3;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Normal Move:Could not get piece at position"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4552}
)
end,
case Moving_piece@3 of
{piece, _, pawn} ->
{some,
{position,
File@1,
six}};
_ ->
none
end;
_ ->
none
end
end,
New_status = case erlang:element(5, Game) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule,
Threefold_repetition_rule}} ->
New_fifty_move_rule = case Fifty_move_rule of
0 ->
0;
_ ->
Fifty_move_rule - 1
end,
Threefold_position = {three_fold_position,
erlang:element(3, Game),
erlang:element(2, Game),
erlang:element(11, Game),
erlang:element(7, Game),
erlang:element(8, Game),
erlang:element(9, Game),
erlang:element(10, Game)},
New_threefold_repetition_rule = case gleam@dict:get(
Threefold_repetition_rule,
Threefold_position
) of
{error, nil} ->
Threefold_repetition_rule;
{ok, 0} ->
gleam@dict:delete(
Threefold_repetition_rule,
Threefold_position
);
{ok, 1} ->
gleam@dict:delete(
Threefold_repetition_rule,
Threefold_position
);
{ok, Count} ->
gleam@dict:insert(
Threefold_repetition_rule,
Threefold_position,
Count - 1
)
end,
{some,
{in_progress,
New_fifty_move_rule,
New_threefold_repetition_rule}};
{some, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Normal Move: trying to undo a move in a finished game is not possible"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4604})
end,
New_game_state@2 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@1,
New_turn
),
New_history
),
New_ply
),
New_status
),
New_white_kingside_castle
),
New_white_queenside_castle
),
New_black_kingside_castle
),
New_black_queenside_castle
),
New_en_passant
),
{ok, New_game_state@2}
end);
{move_with_capture, {castle, From@1, To@1}, _} ->
Rook_castling_target_square = case To@1 of
{position, g, one} ->
{position, f, one};
{position, g, eight} ->
{position, f, eight};
{position, c, one} ->
{position, d, one};
{position, c, eight} ->
{position, d, eight};
_ ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing Castle Move: Invalid castle move"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4636})
end,
gleam@result:'try'(
case board:remove_piece_at_position(
erlang:element(2, Game),
Rook_castling_target_square
) of
{ok, Board} ->
{ok, Board};
{error, _} ->
{error,
<<"Undoing Castle Move: Could not remove piece at position"/utf8>>}
end,
fun(New_board@4) ->
New_game_state@3 = erlang:setelement(
2,
Game,
New_board@4
),
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, New_game_state@3),
To@1
),
fun(New_board@5) ->
New_game_state@4 = erlang:setelement(
2,
New_game_state@3,
New_board@5
),
Rook_castling_origin_square = case To@1 of
{position, g, one} ->
{position, h, one};
{position, g, eight} ->
{position, h, eight};
{position, c, one} ->
{position, a, one};
{position, c, eight} ->
{position, a, eight};
_ ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: Invalid castle move"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4668}
)
end,
New_turn@1 = (case erlang:element(
3,
New_game_state@4
) of
white ->
black;
black ->
white
end),
New_game_state@5 = erlang:setelement(
2,
New_game_state@4,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@4
),
From@1,
{piece, New_turn@1, king}
)
),
New_game_state@6 = erlang:setelement(
2,
New_game_state@5,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@5
),
Rook_castling_origin_square,
{piece, New_turn@1, rook}
)
),
New_ply@1 = erlang:element(6, Game)
- 1,
New_white_kingside_castle@1 = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply@4} ->
case Ply@4 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@4}
end
end,
New_white_queenside_castle@1 = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@5} ->
case Ply@5 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@5}
end
end,
New_black_kingside_castle@1 = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@6} ->
case Ply@6 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@6}
end
end,
New_black_queenside_castle@1 = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@7} ->
case Ply@7 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@7}
end
end,
New_history@1 = Rest,
New_en_passant@1 = case Rest of
[] ->
none;
[Move@2] ->
case Move@2 of
{move_with_capture,
{normal,
{position,
_,
two},
{position,
File@2,
four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@4 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@2,
four}
) of
{some, Piece@4} ->
Piece@4;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 1"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4767}
)
end,
case Moving_piece@4 of
{piece, _, pawn} ->
{some,
{position,
File@2,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position,
_,
seven},
{position,
File@3,
five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@5 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@3,
five}
) of
{some, Piece@5} ->
Piece@5;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 2"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4792}
)
end,
case Moving_piece@5 of
{piece, _, pawn} ->
{some,
{position,
File@3,
six}};
_ ->
none
end;
_ ->
none
end;
[Move@2 | _] ->
case Move@2 of
{move_with_capture,
{normal,
{position,
_,
two},
{position,
File@2,
four},
none},
_} when erlang:element(
3,
Game
) =:= white ->
Moving_piece@4 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@2,
four}
) of
{some, Piece@4} ->
Piece@4;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 1"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4767}
)
end,
case Moving_piece@4 of
{piece, _, pawn} ->
{some,
{position,
File@2,
three}};
_ ->
none
end;
{move_with_capture,
{normal,
{position,
_,
seven},
{position,
File@3,
five},
none},
_} when erlang:element(
3,
Game
) =:= black ->
Moving_piece@5 = case board:get_piece_at_position(
erlang:element(
2,
New_game_state@6
),
{position,
File@3,
five}
) of
{some, Piece@5} ->
Piece@5;
none ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: could not get piece at position 2"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4792}
)
end,
case Moving_piece@5 of
{piece, _, pawn} ->
{some,
{position,
File@3,
six}};
_ ->
none
end;
_ ->
none
end
end,
New_status@1 = case erlang:element(
5,
Game
) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule@1,
Threefold_repetition_rule@1}} ->
case Fifty_move_rule@1 of
0 ->
{some,
{in_progress,
0,
Threefold_repetition_rule@1}};
_ ->
{some,
{in_progress,
Fifty_move_rule@1
- 1,
Threefold_repetition_rule@1}}
end;
{some, _} ->
erlang:error(
#{gleam_error => panic,
message => <<"Undoing Castle Move: Trying to undo a move in a finished game"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4820}
)
end,
New_game_state@7 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@6,
New_turn@1
),
New_history@1
),
New_ply@1
),
New_status@1
),
New_white_kingside_castle@1
),
New_white_queenside_castle@1
),
New_black_kingside_castle@1
),
New_black_queenside_castle@1
),
New_en_passant@1
),
{ok, New_game_state@7}
end
)
end
);
{move_with_capture, {en_passant, From@2, To@2}, _} ->
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(2, Game),
To@2
),
fun(New_board@6) ->
New_game_state@8 = erlang:setelement(
2,
Game,
New_board@6
),
New_game_state@9 = case erlang:element(
3,
Game
) of
black ->
erlang:setelement(
2,
New_game_state@8,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@8
),
From@2,
{piece, white, pawn}
)
);
white ->
erlang:setelement(
2,
New_game_state@8,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@8
),
From@2,
{piece, black, pawn}
)
)
end,
New_game_state@10 = case erlang:element(
3,
Game
) of
black ->
erlang:setelement(
2,
New_game_state@9,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@9
),
{position,
erlang:element(2, To@2),
five},
{piece, black, pawn}
)
);
white ->
erlang:setelement(
2,
New_game_state@9,
board:set_piece_at_position(
erlang:element(
2,
New_game_state@9
),
{position,
erlang:element(2, To@2),
four},
{piece, white, pawn}
)
)
end,
New_ply@2 = erlang:element(6, Game) - 1,
New_white_kingside_castle@2 = case erlang:element(
7,
Game
) of
yes ->
yes;
{no, Ply@8} ->
case Ply@8 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@8}
end
end,
New_white_queenside_castle@2 = case erlang:element(
8,
Game
) of
yes ->
yes;
{no, Ply@9} ->
case Ply@9 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@9}
end
end,
New_black_kingside_castle@2 = case erlang:element(
9,
Game
) of
yes ->
yes;
{no, Ply@10} ->
case Ply@10 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@10}
end
end,
New_black_queenside_castle@2 = case erlang:element(
10,
Game
) of
yes ->
yes;
{no, Ply@11} ->
case Ply@11 =:= erlang:element(
6,
Game
) of
true ->
yes;
false ->
{no, Ply@11}
end
end,
New_turn@2 = (case erlang:element(3, Game) of
white ->
black;
black ->
white
end),
New_history@2 = Rest,
New_en_passant@2 = To@2,
New_status@2 = case erlang:element(5, Game) of
none ->
none;
{some,
{in_progress,
Fifty_move_rule@2,
Threefold_repetition_rule@2}} ->
case Fifty_move_rule@2 of
0 ->
{some,
{in_progress,
0,
Threefold_repetition_rule@2}};
_ ->
{some,
{in_progress,
Fifty_move_rule@2 - 1,
Threefold_repetition_rule@2}}
end;
{some, _} ->
erlang:error(#{gleam_error => panic,
message => <<"Undoing En Passant Move: Trying to undo a move in a finished game"/utf8>>,
module => <<"game"/utf8>>,
function => <<"undo_move"/utf8>>,
line => 4962})
end,
New_game_state@11 = erlang:setelement(
11,
erlang:setelement(
10,
erlang:setelement(
9,
erlang:setelement(
8,
erlang:setelement(
7,
erlang:setelement(
5,
erlang:setelement(
6,
erlang:setelement(
4,
erlang:setelement(
3,
New_game_state@10,
New_turn@2
),
New_history@2
),
New_ply@2
),
New_status@2
),
New_white_kingside_castle@2
),
New_white_queenside_castle@2
),
New_black_kingside_castle@2
),
New_black_queenside_castle@2
),
{some, New_en_passant@2}
),
{ok, New_game_state@11}
end
)
end
end;
{some, _} ->
{ok, Game}
end.
-spec print_board(game()) -> {ok, binary()} | {error, binary()}.
print_board(Game) ->
gleam@result:'try'(
bitboard_repr_to_map_repr(erlang:element(2, Game)),
fun(Board_map) ->
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(<<" +---+---+---+---+---+---+---+---+"/utf8>>),
gleam@list:each(
[{position, a, eight},
{position, b, eight},
{position, c, eight},
{position, d, eight},
{position, e, eight},
{position, f, eight},
{position, g, eight},
{position, h, eight},
{position, a, seven},
{position, b, seven},
{position, c, seven},
{position, d, seven},
{position, e, seven},
{position, f, seven},
{position, g, seven},
{position, h, seven},
{position, a, six},
{position, b, six},
{position, c, six},
{position, d, six},
{position, e, six},
{position, f, six},
{position, g, six},
{position, h, six},
{position, a, five},
{position, b, five},
{position, c, five},
{position, d, five},
{position, e, five},
{position, f, five},
{position, g, five},
{position, h, five},
{position, a, four},
{position, b, four},
{position, c, four},
{position, d, four},
{position, e, four},
{position, f, four},
{position, g, four},
{position, h, four},
{position, a, three},
{position, b, three},
{position, c, three},
{position, d, three},
{position, e, three},
{position, f, three},
{position, g, three},
{position, h, three},
{position, a, two},
{position, b, two},
{position, c, two},
{position, d, two},
{position, e, two},
{position, f, two},
{position, g, two},
{position, h, two},
{position, a, one},
{position, b, one},
{position, c, one},
{position, d, one},
{position, e, one},
{position, f, one},
{position, g, one},
{position, h, one}],
fun(Pos) ->
Piece_to_print = gleam@result:unwrap(
gleam@dict:get(Board_map, Pos),
none
),
case erlang:element(2, Pos) of
a ->
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(
<<<<" "/utf8,
(gleam@int:to_string(
position:rank_to_int(
erlang:element(3, Pos)
)
+ 1
))/binary>>/binary,
" | "/utf8>>
),
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>);
h ->
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>),
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(
<<" +---+---+---+---+---+---+---+---+"/utf8>>
);
_ ->
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>)
end
end
),
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(<<" a b c d e f g h\n"/utf8>>),
{ok, <<"Successfully Printed Board"/utf8>>}
end
).
-spec print_board_from_fen(binary()) -> {ok, binary()} | {error, binary()}.
print_board_from_fen(Fen) ->
Parsed_fen = fen:from_string(Fen),
gleam@result:'try'(
bitboard_repr_to_map_repr(erlang:element(2, Parsed_fen)),
fun(Board_map) ->
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(<<" +---+---+---+---+---+---+---+---+"/utf8>>),
gleam@list:each(
[{position, a, eight},
{position, b, eight},
{position, c, eight},
{position, d, eight},
{position, e, eight},
{position, f, eight},
{position, g, eight},
{position, h, eight},
{position, a, seven},
{position, b, seven},
{position, c, seven},
{position, d, seven},
{position, e, seven},
{position, f, seven},
{position, g, seven},
{position, h, seven},
{position, a, six},
{position, b, six},
{position, c, six},
{position, d, six},
{position, e, six},
{position, f, six},
{position, g, six},
{position, h, six},
{position, a, five},
{position, b, five},
{position, c, five},
{position, d, five},
{position, e, five},
{position, f, five},
{position, g, five},
{position, h, five},
{position, a, four},
{position, b, four},
{position, c, four},
{position, d, four},
{position, e, four},
{position, f, four},
{position, g, four},
{position, h, four},
{position, a, three},
{position, b, three},
{position, c, three},
{position, d, three},
{position, e, three},
{position, f, three},
{position, g, three},
{position, h, three},
{position, a, two},
{position, b, two},
{position, c, two},
{position, d, two},
{position, e, two},
{position, f, two},
{position, g, two},
{position, h, two},
{position, a, one},
{position, b, one},
{position, c, one},
{position, d, one},
{position, e, one},
{position, f, one},
{position, g, one},
{position, h, one}],
fun(Pos) ->
Piece_to_print = gleam@result:unwrap(
gleam@dict:get(Board_map, Pos),
none
),
case erlang:element(2, Pos) of
a ->
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(
<<<<" "/utf8,
(gleam@int:to_string(
position:rank_to_int(
erlang:element(3, Pos)
)
+ 1
))/binary>>/binary,
" | "/utf8>>
),
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>);
h ->
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>),
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(
<<" +---+---+---+---+---+---+---+---+"/utf8>>
);
_ ->
gleam@io:print(case Piece_to_print of
{some, {piece, white, pawn}} ->
<<"♙"/utf8>>;
{some, {piece, white, knight}} ->
<<"♘"/utf8>>;
{some, {piece, white, bishop}} ->
<<"♗"/utf8>>;
{some, {piece, white, rook}} ->
<<"♖"/utf8>>;
{some, {piece, white, queen}} ->
<<"♕"/utf8>>;
{some, {piece, white, king}} ->
<<"♔"/utf8>>;
{some, {piece, black, pawn}} ->
<<"♟"/utf8>>;
{some, {piece, black, knight}} ->
<<"♞"/utf8>>;
{some, {piece, black, bishop}} ->
<<"♝"/utf8>>;
{some, {piece, black, rook}} ->
<<"♜"/utf8>>;
{some, {piece, black, queen}} ->
<<"♛"/utf8>>;
{some, {piece, black, king}} ->
<<"♚"/utf8>>;
none ->
<<" "/utf8>>
end),
gleam@io:print(<<" | "/utf8>>)
end
end
),
gleam@io:print(<<"\n"/utf8>>),
gleam@io:print(<<" a b c d e f g h\n"/utf8>>),
{ok, <<"Successfully printed board"/utf8>>}
end
).
-spec generate_en_passant_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_en_passant_pseudo_legal_move_list(Color, Game) ->
case erlang:element(11, Game) of
none ->
{ok, []};
{some, Ep_position} ->
Ep_bitboard = position:to_bitboard(Ep_position),
Pawn_bitboard = pawn_squares(Color, erlang:element(2, Game)),
Ep_attacker_bitboard = case Color of
white ->
West_east_attacker_bb = bitboard:'and'(
bitboard:'and'(
bitboard:shift_right(Ep_bitboard, 7),
Pawn_bitboard
),
2#1111111011111110111111101111111011111110111111101111111011111110
),
East_west_attacker_bb = bitboard:'and'(
bitboard:'and'(
bitboard:shift_right(Ep_bitboard, 9),
Pawn_bitboard
),
2#0111111101111111011111110111111101111111011111110111111101111111
),
bitboard:'or'(West_east_attacker_bb, East_west_attacker_bb);
black ->
West_east_attacker_bb@1 = bitboard:'and'(
bitboard:'and'(
bitboard:shift_left(Ep_bitboard, 7),
Pawn_bitboard
),
2#0111111101111111011111110111111101111111011111110111111101111111
),
East_west_attacker_bb@1 = bitboard:'and'(
bitboard:'and'(
bitboard:shift_left(Ep_bitboard, 9),
Pawn_bitboard
),
2#1111111011111110111111101111111011111110111111101111111011111110
),
bitboard:'or'(
West_east_attacker_bb@1,
East_west_attacker_bb@1
)
end,
gleam@result:'try'(
board:get_positions(Ep_attacker_bitboard),
fun(Ep_attacker_positions) ->
Ep_moves = gleam@list:map(
Ep_attacker_positions,
fun(Position) -> {en_passant, Position, Ep_position} end
),
{ok, Ep_moves}
end
)
end.
-spec generate_king_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_king_pseudo_legal_move_list(Color, Game) ->
King_bitboard = case Color of
white ->
erlang:element(8, erlang:element(2, Game));
black ->
erlang:element(2, erlang:element(2, Game))
end,
gleam@result:'try'(
board:get_positions(King_bitboard),
fun(King_origin_squares) ->
gleam@list:fold(
King_origin_squares,
{ok, []},
fun(Collector, Origin) ->
King_bitboard@1 = board:from_position(Origin),
North_west_north_east_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:shift_left(King_bitboard@1, 9),
2#1111111011111110111111101111111011111110111111101111111011111110
),
bitboard:'and'(
bitboard:shift_left(King_bitboard@1, 7),
2#0111111101111111011111110111111101111111011111110111111101111111
)
),
South_west_south_east_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:shift_right(King_bitboard@1, 9),
2#0111111101111111011111110111111101111111011111110111111101111111
),
bitboard:'and'(
bitboard:shift_right(King_bitboard@1, 7),
2#1111111011111110111111101111111011111110111111101111111011111110
)
),
West_east_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:shift_left(King_bitboard@1, 1),
2#1111111011111110111111101111111011111110111111101111111011111110
),
bitboard:'and'(
bitboard:shift_right(King_bitboard@1, 1),
2#0111111101111111011111110111111101111111011111110111111101111111
)
),
North_south_target_squares = bitboard:'or'(
bitboard:shift_left(King_bitboard@1, 8),
bitboard:shift_right(King_bitboard@1, 8)
),
King_target_squares = bitboard:'or'(
bitboard:'or'(
North_west_north_east_target_squares,
South_west_south_east_target_squares
),
bitboard:'or'(
West_east_target_squares,
North_south_target_squares
)
),
List_of_friendly_piece_bitboards = case Color of
white ->
[erlang:element(8, erlang:element(2, Game)),
erlang:element(9, erlang:element(2, Game)),
erlang:element(10, erlang:element(2, Game)),
erlang:element(11, erlang:element(2, Game)),
erlang:element(12, erlang:element(2, Game)),
erlang:element(13, erlang:element(2, Game))];
black ->
[erlang:element(2, erlang:element(2, Game)),
erlang:element(3, erlang:element(2, Game)),
erlang:element(4, erlang:element(2, Game)),
erlang:element(5, erlang:element(2, Game)),
erlang:element(6, erlang:element(2, Game)),
erlang:element(7, erlang:element(2, Game))]
end,
Friendly_pieces = gleam@list:fold(
List_of_friendly_piece_bitboards,
0,
fun(Collector@1, Next) ->
bitboard:'or'(Collector@1, Next)
end
),
King_unblocked_target_square_bb = bitboard:'and'(
King_target_squares,
bitboard:'not'(Friendly_pieces)
),
Captures = case Color of
white ->
bitboard:'and'(
King_unblocked_target_square_bb,
occupied_squares_black(erlang:element(2, Game))
);
black ->
bitboard:'and'(
King_unblocked_target_square_bb,
occupied_squares_white(erlang:element(2, Game))
)
end,
Simple_moves = case Color of
white ->
bitboard:exclusive_or(
King_unblocked_target_square_bb,
Captures
);
black ->
bitboard:exclusive_or(
King_unblocked_target_square_bb,
Captures
)
end,
gleam@result:'try'(
board:get_positions(Simple_moves),
fun(Simple_moves_positions) ->
Simple_moves@1 = gleam@list:map(
Simple_moves_positions,
fun(Dest) -> {normal, Origin, Dest, none} end
),
gleam@result:'try'(
board:get_positions(Captures),
fun(Captures_positions) ->
Captures@1 = gleam@list:map(
Captures_positions,
fun(Dest@1) ->
{normal, Origin, Dest@1, none}
end
),
All_moves = gleam@list:append(
Simple_moves@1,
Captures@1
),
gleam@result:'try'(
Collector,
fun(Collector@2) ->
{ok,
gleam@list:append(
Collector@2,
All_moves
)}
end
)
end
)
end
)
end
)
end
).
-spec generate_knight_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_knight_pseudo_legal_move_list(Color, Game) ->
Knight_bitboard = case Color of
white ->
erlang:element(12, erlang:element(2, Game));
black ->
erlang:element(6, erlang:element(2, Game))
end,
gleam@result:'try'(
board:get_positions(Knight_bitboard),
fun(Knight_origin_squares) ->
gleam@list:fold(
Knight_origin_squares,
{ok, []},
fun(Collector, Origin) ->
Knight_bitboard@1 = board:from_position(Origin),
North_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:shift_left(Knight_bitboard@1, 17),
2#1111111011111110111111101111111011111110111111101111111011111110
),
bitboard:'and'(
bitboard:shift_left(Knight_bitboard@1, 15),
2#0111111101111111011111110111111101111111011111110111111101111111
)
),
South_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:shift_right(Knight_bitboard@1, 17),
2#0111111101111111011111110111111101111111011111110111111101111111
),
bitboard:'and'(
bitboard:shift_right(Knight_bitboard@1, 15),
2#1111111011111110111111101111111011111110111111101111111011111110
)
),
West_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:'and'(
bitboard:shift_right(Knight_bitboard@1, 10),
2#0111111101111111011111110111111101111111011111110111111101111111
),
2#1011111110111111101111111011111110111111101111111011111110111111
),
bitboard:'and'(
bitboard:'and'(
bitboard:shift_left(Knight_bitboard@1, 6),
2#0111111101111111011111110111111101111111011111110111111101111111
),
2#1011111110111111101111111011111110111111101111111011111110111111
)
),
East_target_squares = bitboard:'or'(
bitboard:'and'(
bitboard:'and'(
bitboard:shift_right(Knight_bitboard@1, 6),
2#1111111011111110111111101111111011111110111111101111111011111110
),
2#1111110111111101111111011111110111111101111111011111110111111101
),
bitboard:'and'(
bitboard:'and'(
bitboard:shift_left(Knight_bitboard@1, 10),
2#1111111011111110111111101111111011111110111111101111111011111110
),
2#1111110111111101111111011111110111111101111111011111110111111101
)
),
Knight_target_squares = bitboard:'or'(
bitboard:'or'(
North_target_squares,
South_target_squares
),
bitboard:'or'(West_target_squares, East_target_squares)
),
List_of_friendly_piece_bitboards = case Color of
white ->
[erlang:element(8, erlang:element(2, Game)),
erlang:element(9, erlang:element(2, Game)),
erlang:element(10, erlang:element(2, Game)),
erlang:element(11, erlang:element(2, Game)),
erlang:element(12, erlang:element(2, Game)),
erlang:element(13, erlang:element(2, Game))];
black ->
[erlang:element(2, erlang:element(2, Game)),
erlang:element(3, erlang:element(2, Game)),
erlang:element(4, erlang:element(2, Game)),
erlang:element(5, erlang:element(2, Game)),
erlang:element(6, erlang:element(2, Game)),
erlang:element(7, erlang:element(2, Game))]
end,
Friendly_pieces = gleam@list:fold(
List_of_friendly_piece_bitboards,
0,
fun(Collector@1, Next) ->
bitboard:'or'(Collector@1, Next)
end
),
Knight_unblocked_target_square_bb = bitboard:'and'(
Knight_target_squares,
bitboard:'not'(Friendly_pieces)
),
Captures = case Color of
white ->
bitboard:'and'(
Knight_unblocked_target_square_bb,
occupied_squares_black(erlang:element(2, Game))
);
black ->
bitboard:'and'(
Knight_unblocked_target_square_bb,
occupied_squares_white(erlang:element(2, Game))
)
end,
Simple_moves = case Color of
white ->
bitboard:exclusive_or(
Knight_unblocked_target_square_bb,
Captures
);
black ->
bitboard:exclusive_or(
Knight_unblocked_target_square_bb,
Captures
)
end,
gleam@result:'try'(
board:get_positions(Simple_moves),
fun(Simple_moves_positions) ->
Simple_moves@1 = gleam@list:map(
Simple_moves_positions,
fun(Dest) -> {normal, Origin, Dest, none} end
),
gleam@result:'try'(
board:get_positions(Captures),
fun(Captures_positions) ->
Captures@1 = gleam@list:map(
Captures_positions,
fun(Dest@1) ->
{normal, Origin, Dest@1, none}
end
),
All_moves = gleam@list:append(
Simple_moves@1,
Captures@1
),
gleam@result:'try'(
Collector,
fun(Collector@2) ->
{ok,
gleam@list:append(
Collector@2,
All_moves
)}
end
)
end
)
end
)
end
)
end
).
-spec generate_pawn_attack_set(integer(), color:color()) -> integer().
generate_pawn_attack_set(Pawn_bitboard, Color) ->
case Color of
white ->
East_attack = bitboard:'and'(
bitboard:shift_left(Pawn_bitboard, 9),
2#1111111011111110111111101111111011111110111111101111111011111110
),
West_attack = bitboard:'and'(
bitboard:shift_left(Pawn_bitboard, 7),
2#0111111101111111011111110111111101111111011111110111111101111111
),
All_attacks = bitboard:'or'(East_attack, West_attack),
All_attacks;
black ->
East_attack@1 = bitboard:'and'(
bitboard:shift_right(Pawn_bitboard, 7),
2#1111111011111110111111101111111011111110111111101111111011111110
),
West_attack@1 = bitboard:'and'(
bitboard:shift_right(Pawn_bitboard, 9),
2#0111111101111111011111110111111101111111011111110111111101111111
),
All_attacks@1 = bitboard:'or'(East_attack@1, West_attack@1),
All_attacks@1
end.
-spec generate_pawn_capture_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_pawn_capture_move_list(Color, Game) ->
Pawn_attack_set = case Color of
white ->
generate_pawn_attack_set(
erlang:element(13, erlang:element(2, Game)),
Color
);
black ->
generate_pawn_attack_set(
erlang:element(7, erlang:element(2, Game)),
Color
)
end,
generate_pawn_attack_set(erlang:element(13, erlang:element(2, Game)), Color),
List_of_enemy_piece_bitboards = case Color of
white ->
[erlang:element(2, erlang:element(2, Game)),
erlang:element(3, erlang:element(2, Game)),
erlang:element(4, erlang:element(2, Game)),
erlang:element(5, erlang:element(2, Game)),
erlang:element(6, erlang:element(2, Game)),
erlang:element(7, erlang:element(2, Game))];
black ->
[erlang:element(8, erlang:element(2, Game)),
erlang:element(9, erlang:element(2, Game)),
erlang:element(10, erlang:element(2, Game)),
erlang:element(11, erlang:element(2, Game)),
erlang:element(12, erlang:element(2, Game)),
erlang:element(13, erlang:element(2, Game))]
end,
Enemy_pieces = gleam@list:fold(
List_of_enemy_piece_bitboards,
0,
fun(Collector, Next) -> bitboard:'or'(Collector, Next) end
),
Pawn_capture_destination_set = bitboard:'and'(Pawn_attack_set, Enemy_pieces),
{East_origins@2, West_origins@2} = case Color of
white ->
East_origins = bitboard:'and'(
bitboard:shift_right(Pawn_capture_destination_set, 9),
2#0111111101111111011111110111111101111111011111110111111101111111
),
West_origins = bitboard:'and'(
bitboard:shift_right(Pawn_capture_destination_set, 7),
2#1111111011111110111111101111111011111110111111101111111011111110
),
{bitboard:'and'(
East_origins,
erlang:element(13, erlang:element(2, Game))
),
bitboard:'and'(
West_origins,
erlang:element(13, erlang:element(2, Game))
)};
black ->
West_origins@1 = bitboard:'and'(
bitboard:shift_left(Pawn_capture_destination_set, 9),
2#1111111011111110111111101111111011111110111111101111111011111110
),
East_origins@1 = bitboard:'and'(
bitboard:shift_left(Pawn_capture_destination_set, 7),
2#0111111101111111011111110111111101111111011111110111111101111111
),
{bitboard:'and'(
East_origins@1,
erlang:element(7, erlang:element(2, Game))
),
bitboard:'and'(
West_origins@1,
erlang:element(7, erlang:element(2, Game))
)}
end,
Pawn_capture_origin_set = bitboard:'or'(East_origins@2, West_origins@2),
gleam@result:'try'(
board:get_positions(Pawn_capture_origin_set),
fun(Pawn_capture_origin_list) ->
gleam@result:'try'(
board:get_positions(Pawn_capture_destination_set),
fun(Pawn_capture_destination_list) ->
Pawn_capture_move_list = gleam@list:fold(
Pawn_capture_origin_list,
{ok, []},
fun(Collector@1, Position) ->
gleam@result:'try'(case Color of
white ->
board:get_positions(
bitboard:'and'(
bitboard:shift_left(
position:to_bitboard(
Position
),
9
),
2#1111111011111110111111101111111011111110111111101111111011111110
)
);
black ->
board:get_positions(
bitboard:'and'(
bitboard:shift_right(
position:to_bitboard(
Position
),
7
),
2#1111111011111110111111101111111011111110111111101111111011111110
)
)
end, fun(East_attack) ->
East_moves@2 = case East_attack of
[] ->
[];
[East_attack@1] ->
East_attack_in_dest_list = gleam@list:contains(
Pawn_capture_destination_list,
East_attack@1
),
East_moves@1 = case East_attack_in_dest_list of
false ->
[];
true ->
East_moves = case East_attack@1 of
{position, _, eight} when Color =:= white ->
[{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
queen}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
rook}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
bishop}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
knight}}}];
{position, _, one} when Color =:= black ->
[{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
queen}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
rook}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
bishop}}},
{normal,
Position,
East_attack@1,
{some,
{piece,
Color,
knight}}}];
_ ->
[{normal,
Position,
East_attack@1,
none}]
end,
East_moves
end,
East_moves@1;
_ ->
erlang:error(#{gleam_error => panic,
message => <<"panic expression evaluated"/utf8>>,
module => <<"game"/utf8>>,
function => <<"generate_pawn_capture_move_list"/utf8>>,
line => 3380})
end,
gleam@result:'try'(case Color of
white ->
board:get_positions(
bitboard:'and'(
bitboard:shift_left(
position:to_bitboard(
Position
),
7
),
2#0111111101111111011111110111111101111111011111110111111101111111
)
);
black ->
board:get_positions(
bitboard:'and'(
bitboard:shift_right(
position:to_bitboard(
Position
),
9
),
2#0111111101111111011111110111111101111111011111110111111101111111
)
)
end, fun(West_attack) ->
West_moves@2 = case West_attack of
[] ->
[];
[West_attack@1] ->
West_attack_in_dest_list = gleam@list:contains(
Pawn_capture_destination_list,
West_attack@1
),
West_moves@1 = case West_attack_in_dest_list of
false ->
[];
true ->
West_moves = case West_attack@1 of
{position,
_,
eight} when Color =:= white ->
[{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
queen}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
rook}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
bishop}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
knight}}}];
{position,
_,
one} when Color =:= black ->
[{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
queen}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
rook}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
bishop}}},
{normal,
Position,
West_attack@1,
{some,
{piece,
Color,
knight}}}];
_ ->
[{normal,
Position,
West_attack@1,
none}]
end,
West_moves
end,
West_moves@1;
_ ->
erlang:error(
#{gleam_error => panic,
message => <<"panic expression evaluated"/utf8>>,
module => <<"game"/utf8>>,
function => <<"generate_pawn_capture_move_list"/utf8>>,
line => 3461}
)
end,
gleam@result:'try'(
Collector@1,
fun(Collector@2) ->
{ok,
gleam@list:append(
gleam@list:append(
Collector@2,
East_moves@2
),
West_moves@2
)}
end
)
end)
end)
end
),
Pawn_capture_move_list
end
)
end
).
-spec generate_pawn_starting_rank_double_move_bitboard(color:color(), game()) -> integer().
generate_pawn_starting_rank_double_move_bitboard(Color, Game) ->
case Color of
white ->
White_pawn_target_squares = bitboard:'and'(
erlang:element(13, erlang:element(2, Game)),
2#0000000000000000000000000000000000000000000000001111111100000000
),
White_pawn_target_squares@1 = bitboard:'or'(
bitboard:shift_left(White_pawn_target_squares, 16),
bitboard:shift_left(White_pawn_target_squares, 8)
),
Occupied_squares = occupied_squares(erlang:element(2, Game)),
Moves = bitboard:'and'(
Occupied_squares,
White_pawn_target_squares@1
),
Moves@1 = bitboard:'or'(
bitboard:shift_left(
bitboard:'and'(
Moves,
2#0000000000000000000000000000000000000000111111110000000000000000
),
8
),
Moves
),
Moves@2 = bitboard:exclusive_or(
Moves@1,
White_pawn_target_squares@1
),
Moves@3 = bitboard:'and'(
Moves@2,
bitboard:'not'(
2#0000000000000000000000000000000000000000111111110000000000000000
)
),
Moves@3;
black ->
Black_pawn_target_squares = bitboard:'and'(
erlang:element(7, erlang:element(2, Game)),
2#0000000011111111000000000000000000000000000000000000000000000000
),
Black_pawn_target_squares@1 = bitboard:'or'(
bitboard:shift_right(Black_pawn_target_squares, 16),
bitboard:shift_right(Black_pawn_target_squares, 8)
),
Occupied_squares@1 = occupied_squares(erlang:element(2, Game)),
Moves@4 = bitboard:'and'(
Occupied_squares@1,
Black_pawn_target_squares@1
),
Moves@5 = bitboard:'or'(
bitboard:shift_right(
bitboard:'and'(
Moves@4,
2#0000000000000000111111110000000000000000000000000000000000000000
),
8
),
Moves@4
),
Moves@6 = bitboard:exclusive_or(
Moves@5,
Black_pawn_target_squares@1
),
Moves@7 = bitboard:'and'(
Moves@6,
bitboard:'not'(
2#0000000000000000111111110000000000000000000000000000000000000000
)
),
Moves@7
end.
-spec generate_pawn_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_pawn_pseudo_legal_move_list(Color, Game) ->
gleam@result:'try'(
generate_pawn_capture_move_list(Color, Game),
fun(Capture_list) ->
Moves_no_captures = generate_pawn_non_capture_move_bitboard(
Color,
Game
),
gleam@result:'try'(
board:get_positions(Moves_no_captures),
fun(Non_capture_dest_list) ->
Non_capture_move_list = gleam@list:fold(
Non_capture_dest_list,
[],
fun(Acc, Dest) ->
Origin = position:get_rear_position(Dest, Color),
Moves = case Dest of
{position, _, eight} when Color =:= white ->
[{normal,
Origin,
Dest,
{some, {piece, Color, queen}}},
{normal,
Origin,
Dest,
{some, {piece, Color, rook}}},
{normal,
Origin,
Dest,
{some, {piece, Color, bishop}}},
{normal,
Origin,
Dest,
{some, {piece, Color, knight}}}];
{position, _, one} when Color =:= black ->
[{normal,
Origin,
Dest,
{some, {piece, Color, queen}}},
{normal,
Origin,
Dest,
{some, {piece, Color, rook}}},
{normal,
Origin,
Dest,
{some, {piece, Color, bishop}}},
{normal,
Origin,
Dest,
{some, {piece, Color, knight}}}];
_ ->
[{normal, Origin, Dest, none}]
end,
gleam@list:append(Acc, Moves)
end
),
Initial_rank_double_move_list = generate_pawn_starting_rank_double_move_bitboard(
Color,
Game
),
gleam@result:'try'(
board:get_positions(Initial_rank_double_move_list),
fun(Initial_rank_double_dest_list) ->
Initial_rank_double_move_list@1 = gleam@list:map(
Initial_rank_double_dest_list,
fun(Dest@1) -> case Color of
white ->
case erlang:element(2, Dest@1) of
a ->
{normal,
{position, a, two},
Dest@1,
none};
b ->
{normal,
{position, b, two},
Dest@1,
none};
c ->
{normal,
{position, c, two},
Dest@1,
none};
d ->
{normal,
{position, d, two},
Dest@1,
none};
e ->
{normal,
{position, e, two},
Dest@1,
none};
f ->
{normal,
{position, f, two},
Dest@1,
none};
g ->
{normal,
{position, g, two},
Dest@1,
none};
h ->
{normal,
{position, h, two},
Dest@1,
none}
end;
black ->
case erlang:element(2, Dest@1) of
a ->
{normal,
{position, a, seven},
Dest@1,
none};
b ->
{normal,
{position, b, seven},
Dest@1,
none};
c ->
{normal,
{position, c, seven},
Dest@1,
none};
d ->
{normal,
{position, d, seven},
Dest@1,
none};
e ->
{normal,
{position, e, seven},
Dest@1,
none};
f ->
{normal,
{position, f, seven},
Dest@1,
none};
g ->
{normal,
{position, g, seven},
Dest@1,
none};
h ->
{normal,
{position, h, seven},
Dest@1,
none}
end
end end
),
{ok,
gleam@list:append(
gleam@list:append(
Capture_list,
Non_capture_move_list
),
Initial_rank_double_move_list@1
)}
end
)
end
)
end
).
-spec is_king_in_check(game(), color:color()) -> {ok, boolean()} |
{error, binary()}.
is_king_in_check(Game, Color) ->
Enemy_color = (case Color of
white ->
black;
black ->
white
end),
gleam@result:'try'(
begin
King_bb = case Color of
white ->
erlang:element(8, erlang:element(2, Game));
black ->
erlang:element(2, erlang:element(2, Game))
end,
gleam@result:'try'(case board:get_positions(King_bb) of
{ok, [King_pos]} ->
{ok, King_pos};
_ ->
{error, <<"Invalid king position"/utf8>>}
end, fun(King_pos@1) ->
Rook_bb = case Color of
white ->
erlang:element(4, erlang:element(2, Game));
black ->
erlang:element(10, erlang:element(2, Game))
end,
King_rook_ray_bb = begin
_pipe = bitboard:'or'(
look_up_east_ray_bb(King_pos@1),
look_up_west_ray_bb(King_pos@1)
),
_pipe@1 = bitboard:'or'(
_pipe,
look_up_north_ray_bb(King_pos@1)
),
bitboard:'or'(_pipe@1, look_up_south_ray_bb(King_pos@1))
end,
Viable_attacking_rook_bb = bitboard:'and'(
Rook_bb,
King_rook_ray_bb
),
gleam@result:'try'(case Viable_attacking_rook_bb of
0 ->
{ok, []};
_ ->
generate_rook_pseudo_legal_move_list(
Enemy_color,
Game
)
end, fun(Rook_move_list) ->
Bishop_bb = case Color of
white ->
erlang:element(5, erlang:element(2, Game));
black ->
erlang:element(11, erlang:element(2, Game))
end,
King_bishop_ray_bb = begin
_pipe@2 = bitboard:'or'(
look_up_north_east_ray_bb(King_pos@1),
look_up_north_west_ray_bb(King_pos@1)
),
_pipe@3 = bitboard:'or'(
_pipe@2,
look_up_south_east_ray_bb(King_pos@1)
),
bitboard:'or'(
_pipe@3,
look_up_south_west_ray_bb(King_pos@1)
)
end,
Viable_attacking_bishop_bb = bitboard:'and'(
Bishop_bb,
King_bishop_ray_bb
),
gleam@result:'try'(
case Viable_attacking_bishop_bb of
0 ->
{ok, []};
_ ->
generate_bishop_pseudo_legal_move_list(
Enemy_color,
Game
)
end,
fun(Bishop_move_list) ->
Queen_bb = case Color of
white ->
erlang:element(
3,
erlang:element(2, Game)
);
black ->
erlang:element(
9,
erlang:element(2, Game)
)
end,
King_queen_ray_bb = bitboard:'or'(
King_rook_ray_bb,
King_bishop_ray_bb
),
Viable_attacking_queen_bb = bitboard:'and'(
Queen_bb,
King_queen_ray_bb
),
gleam@result:'try'(
case Viable_attacking_queen_bb of
0 ->
{ok, []};
_ ->
generate_queen_pseudo_legal_move_list(
Enemy_color,
Game
)
end,
fun(Queen_move_list) ->
Knight_bb = case Color of
white ->
erlang:element(
6,
erlang:element(2, Game)
);
black ->
erlang:element(
12,
erlang:element(2, Game)
)
end,
King_knight_target_bb = look_up_knight_target_bb(
King_pos@1
),
Viable_attacking_knight_bb = bitboard:'and'(
Knight_bb,
King_knight_target_bb
),
gleam@result:'try'(
case Viable_attacking_knight_bb of
0 ->
{ok, []};
_ ->
generate_knight_pseudo_legal_move_list(
Enemy_color,
Game
)
end,
fun(Knight_move_list) ->
gleam@result:'try'(
generate_pawn_pseudo_legal_move_list(
Enemy_color,
Game
),
fun(Pawn_move_list) ->
gleam@result:'try'(
generate_king_pseudo_legal_move_list(
Enemy_color,
Game
),
fun(
Enemy_king_move_list
) ->
List_of_move_lists = [Rook_move_list,
Bishop_move_list,
Queen_move_list,
Knight_move_list,
Pawn_move_list,
Enemy_king_move_list],
Move_list = gleam@list:fold(
List_of_move_lists,
[],
fun(
Collector,
Next
) ->
gleam@list:append(
Collector,
Next
)
end
),
{ok,
Move_list}
end
)
end
)
end
)
end
)
end
)
end)
end)
end,
fun(Enemy_move_list) ->
gleam@result:'try'(
({ok,
begin
_pipe@4 = Enemy_move_list,
gleam@list:filter(
_pipe@4,
fun(Move) ->
Piece = piece_at_position(
Game,
erlang:element(3, Move)
),
case Piece of
none ->
false;
{some, Piece@1} ->
(erlang:element(2, Piece@1) =:= Color)
andalso (erlang:element(3, Piece@1) =:= king)
end
end
)
end}),
fun(Enemy_move_list@1) ->
{ok, gleam@list:length(Enemy_move_list@1) > 0}
end
)
end
).
-spec is_move_legal(game(), move:move()) -> {ok, boolean()} | {error, binary()}.
is_move_legal(Game, Move) ->
gleam@result:'try'(
apply_move_raw(Game, Move),
fun(New_game_state) -> case Move of
{normal, _, _, _} ->
gleam@result:'try'(
is_king_in_check(
New_game_state,
erlang:element(3, Game)
),
fun(Is_king_in_check) -> {ok, not Is_king_in_check} end
);
{en_passant, _, _} ->
gleam@result:'try'(
is_king_in_check(
New_game_state,
erlang:element(3, Game)
),
fun(Is_king_in_check) -> {ok, not Is_king_in_check} end
);
{castle, _, To} ->
gleam@result:'try'(
is_king_in_check(Game, erlang:element(3, Game)),
fun(Is_king_in_check_ok) -> case Is_king_in_check_ok of
true ->
{ok, false};
false ->
gleam@result:'try'(
is_king_in_check(
New_game_state,
erlang:element(3, Game)
),
fun(Is_king_in_check_ok@1) ->
case Is_king_in_check_ok@1 of
true ->
{ok, false};
false ->
King_castling_target_square = case To of
{position, g, one} ->
{ok,
{position,
f,
one}};
{position, g, eight} ->
{ok,
{position,
f,
eight}};
{position, c, one} ->
{ok,
{position,
d,
one}};
{position, c, eight} ->
{ok,
{position,
d,
eight}};
_ ->
{error,
<<"Invalid castle move"/utf8>>}
end,
case King_castling_target_square of
{error, _} ->
{ok, false};
{ok,
King_castling_target_square@1} ->
New_game_state@1 = erlang:setelement(
2,
New_game_state,
board:set_piece_at_position(
erlang:element(
2,
New_game_state
),
King_castling_target_square@1,
{piece,
erlang:element(
3,
Game
),
king}
)
),
gleam@result:'try'(
board:remove_piece_at_position(
erlang:element(
2,
New_game_state@1
),
To
),
fun(New_board) ->
New_game_state@2 = erlang:setelement(
2,
New_game_state@1,
New_board
),
gleam@result:'try'(
is_king_in_check(
New_game_state@2,
erlang:element(
3,
Game
)
),
fun(
Is_king_in_check_ok@2
) ->
case Is_king_in_check_ok@2 of
true ->
{ok,
false};
false ->
{ok,
true}
end
end
)
end
)
end
end
end
)
end end
)
end end
).
-spec generate_castling_pseudo_legal_move_list(color:color(), game()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_castling_pseudo_legal_move_list(Color, Game) ->
King_bitboard = case Color of
white ->
erlang:element(8, erlang:element(2, Game));
black ->
erlang:element(2, erlang:element(2, Game))
end,
gleam@result:'try'(case board:get_positions(King_bitboard) of
{ok, []} ->
{error, <<"No king found on the board"/utf8>>};
{ok, [Position]} ->
{ok, Position};
_ ->
{error, <<"More than one king found on the board"/utf8>>}
end, fun(King_position) ->
King_position_flag = case King_position of
{position, e, one} when Color =:= white ->
true;
{position, e, eight} when Color =:= black ->
true;
_ ->
false
end,
Rook_bitboard = case Color of
white ->
erlang:element(10, erlang:element(2, Game));
black ->
erlang:element(4, erlang:element(2, Game))
end,
Queenside_rook_flag = case Color of
white ->
case bitboard:'and'(
bitboard:'and'(
Rook_bitboard,
2#0000000100000001000000010000000100000001000000010000000100000001
),
2#0000000000000000000000000000000000000000000000000000000011111111
) of
0 ->
false;
_ ->
true
end;
black ->
case bitboard:'and'(
bitboard:'and'(
Rook_bitboard,
2#0000000100000001000000010000000100000001000000010000000100000001
),
2#1111111100000000000000000000000000000000000000000000000000000000
) of
0 ->
false;
_ ->
true
end
end,
Kingside_rook_flag = case Color of
white ->
case bitboard:'and'(
bitboard:'and'(
Rook_bitboard,
2#1000000010000000100000001000000010000000100000001000000010000000
),
2#0000000000000000000000000000000000000000000000000000000011111111
) of
0 ->
false;
_ ->
true
end;
black ->
case bitboard:'and'(
bitboard:'and'(
Rook_bitboard,
2#1000000010000000100000001000000010000000100000001000000010000000
),
2#1111111100000000000000000000000000000000000000000000000000000000
) of
0 ->
false;
_ ->
true
end
end,
Queenside_clear_flag = case Color of
white ->
case bitboard:'and'(
2#0000000000000000000000000000000000000000000000000000000000001110,
occupied_squares(erlang:element(2, Game))
) of
0 ->
true;
_ ->
false
end;
black ->
case bitboard:'and'(
2#0000111000000000000000000000000000000000000000000000000000000000,
occupied_squares(erlang:element(2, Game))
) of
0 ->
true;
_ ->
false
end
end,
Kingside_clear_flag = case Color of
white ->
case bitboard:'and'(
2#0000000000000000000000000000000000000000000000000000000001100000,
occupied_squares(erlang:element(2, Game))
) of
0 ->
true;
_ ->
false
end;
black ->
case bitboard:'and'(
2#0110000000000000000000000000000000000000000000000000000000000000,
occupied_squares(erlang:element(2, Game))
) of
0 ->
true;
_ ->
false
end
end,
Queenside_castle = case Color of
white ->
erlang:element(8, Game);
black ->
erlang:element(10, Game)
end,
Kingside_castle = case Color of
white ->
erlang:element(7, Game);
black ->
erlang:element(9, Game)
end,
Castling_moves = gleam@list:append(
case [Queenside_rook_flag,
Queenside_clear_flag,
King_position_flag] of
[true, true, true] when Queenside_castle =:= yes ->
case Color of
white ->
[{castle, King_position, {position, c, one}}];
black ->
[{castle, King_position, {position, c, eight}}]
end;
_ ->
[]
end,
case [Kingside_rook_flag,
Kingside_clear_flag,
King_position_flag] of
[true, true, true] when Kingside_castle =:= yes ->
case Color of
white ->
[{castle, King_position, {position, g, one}}];
black ->
[{castle, King_position, {position, g, eight}}]
end;
_ ->
[]
end
),
{ok, Castling_moves}
end).
-spec generate_pseudo_legal_move_list(game(), color:color()) -> {ok,
list(move:move())} |
{error, binary()}.
generate_pseudo_legal_move_list(Game, Color) ->
gleam@result:'try'(
generate_queen_pseudo_legal_move_list(Color, Game),
fun(Queen_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_king_pseudo_legal_move_list(Color, Game),
fun(King_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_castling_pseudo_legal_move_list(Color, Game),
fun(Castling_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_en_passant_pseudo_legal_move_list(
Color,
Game
),
fun(En_passant_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_rook_pseudo_legal_move_list(
Color,
Game
),
fun(Rook_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_pawn_pseudo_legal_move_list(
Color,
Game
),
fun(Pawn_pseudo_legal_move_list) ->
gleam@result:'try'(
generate_knight_pseudo_legal_move_list(
Color,
Game
),
fun(
Knight_pseudo_legal_move_list
) ->
gleam@result:'try'(
generate_bishop_pseudo_legal_move_list(
Color,
Game
),
fun(
Bishop_pseudo_legal_move_list
) ->
List_of_move_lists = [Rook_pseudo_legal_move_list,
Bishop_pseudo_legal_move_list,
Knight_pseudo_legal_move_list,
Pawn_pseudo_legal_move_list,
Queen_pseudo_legal_move_list,
King_pseudo_legal_move_list,
Castling_pseudo_legal_move_list,
En_passant_pseudo_legal_move_list],
Move_list = gleam@list:fold(
List_of_move_lists,
[],
fun(
Collector,
Next
) ->
gleam@list:append(
Collector,
Next
)
end
),
{ok,
Move_list}
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
).
-spec all_legal_moves(game()) -> {ok, list(move:move())} | {error, binary()}.
all_legal_moves(Game) ->
case erlang:element(5, Game) of
{some, {in_progress, _, _}} ->
Legal_moves = (gleam@result:'try'(
generate_pseudo_legal_move_list(Game, erlang:element(3, Game)),
fun(Pseudo_legal_move_list) ->
{ok,
begin
_pipe = Pseudo_legal_move_list,
gleam@list:filter(
_pipe,
fun(Move) -> case is_move_legal(Game, Move) of
{ok, Legality} ->
Legality;
{error, _} ->
false
end end
)
end}
end
)),
Legal_moves;
none ->
Legal_moves = (gleam@result:'try'(
generate_pseudo_legal_move_list(Game, erlang:element(3, Game)),
fun(Pseudo_legal_move_list) ->
{ok,
begin
_pipe = Pseudo_legal_move_list,
gleam@list:filter(
_pipe,
fun(Move) -> case is_move_legal(Game, Move) of
{ok, Legality} ->
Legality;
{error, _} ->
false
end end
)
end}
end
)),
Legal_moves;
{some, _} ->
{ok, []}
end.
-spec has_moves(game()) -> {ok, boolean()} | {error, binary()}.
has_moves(Game) ->
gleam@result:'try'(
all_legal_moves(Game),
fun(Move_list) -> {ok, not gleam@list:is_empty(Move_list)} end
).
-spec apply_move(game(), move:move()) -> {ok, game()} | {error, binary()}.
apply_move(Game, Move) ->
case erlang:element(5, Game) of
none ->
gleam@result:'try'(
(gleam@result:'try'(
generate_pseudo_legal_move_list(
Game,
erlang:element(3, Game)
),
fun(Pseudo_legal_move_list) ->
{ok,
begin
_pipe = Pseudo_legal_move_list,
gleam@list:filter(
_pipe,
fun(Move@1) ->
case is_move_legal(Game, Move@1) of
{ok, Legality} ->
Legality;
{error, _} ->
false
end
end
)
end}
end
)),
fun(Legal_moves) ->
New_game_state@1 = case gleam@list:contains(
Legal_moves,
Move
) of
true ->
New_game_state = apply_move_raw(Game, Move),
New_game_state;
false ->
{ok, Game}
end,
New_game_state@1
end
);
{some, {in_progress, _, _}} ->
gleam@result:'try'(
(gleam@result:'try'(
generate_pseudo_legal_move_list(
Game,
erlang:element(3, Game)
),
fun(Pseudo_legal_move_list@1) ->
{ok,
begin
_pipe@1 = Pseudo_legal_move_list@1,
gleam@list:filter(
_pipe@1,
fun(Move@2) ->
case is_move_legal(Game, Move@2) of
{ok, Legality@1} ->
Legality@1;
{error, _} ->
false
end
end
)
end}
end
)),
fun(Legal_moves@1) ->
New_game_state@3 = case gleam@list:contains(
Legal_moves@1,
Move
) of
true ->
New_game_state@2 = apply_move_raw(Game, Move),
New_game_state@2;
false ->
{ok, Game}
end,
gleam@result:'try'(
New_game_state@3,
fun(New_game_state@4) ->
gleam@result:'try'(
has_moves(New_game_state@4),
fun(Has_moves) ->
gleam@result:'try'(
is_king_in_check(
New_game_state@4,
erlang:element(3, New_game_state@4)
),
fun(Is_king_in_check) ->
New_game_state@6 = case [Is_king_in_check,
Has_moves] of
[true, false] ->
Winner = case erlang:element(
3,
New_game_state@4
) of
white ->
black;
black ->
white
end,
{ok,
erlang:setelement(
5,
New_game_state@4,
{some,
{win,
Winner,
<<"Checkmate"/utf8>>}}
)};
[true, true] ->
New_status@2 = case Move of
{normal, From, To, _} ->
gleam@result:'try'(
case board:get_piece_at_position(
erlang:element(
2,
Game
),
From
) of
{some,
Piece} ->
{ok,
Piece};
none ->
{error,
<<"no piece at from position"/utf8>>}
end,
fun(
Moving_piece
) ->
case erlang:element(
5,
Game
) of
none ->
{ok,
none};
{some,
{in_progress,
Fifty_move_rule,
Threefold_repetition_rule}} ->
Captured_piece = piece_at_position(
Game,
To
),
New_fifty_move_rule = case Captured_piece of
{some,
_} ->
0;
none ->
case Moving_piece of
{piece,
_,
pawn} ->
0;
_ ->
Fifty_move_rule
+ 1
end
end,
New_status = case (New_fifty_move_rule
div 2)
+ 1 of
50 ->
{some,
{draw,
fifty_move_rule}};
_ ->
{some,
{in_progress,
New_fifty_move_rule,
Threefold_repetition_rule}}
end,
{New_threefold_repetition_rule@3,
Count@2} = case Captured_piece of
{some,
_} ->
{Threefold_repetition_rule,
0};
none ->
New_threefold_position = {three_fold_position,
erlang:element(
3,
Game
),
erlang:element(
2,
Game
),
erlang:element(
11,
Game
),
erlang:element(
7,
Game
),
erlang:element(
8,
Game
),
erlang:element(
9,
Game
),
erlang:element(
10,
Game
)},
{New_threefold_repetition_rule@2,
Count@1} = case gleam@dict:get(
Threefold_repetition_rule,
New_threefold_position
) of
{error,
_} ->
New_threefold_repetition_rule = gleam@dict:insert(
Threefold_repetition_rule,
New_threefold_position,
1
),
{New_threefold_repetition_rule,
1};
{ok,
Count} ->
New_threefold_repetition_rule@1 = gleam@dict:insert(
Threefold_repetition_rule,
New_threefold_position,
Count
+ 1
),
{New_threefold_repetition_rule@1,
Count
+ 1}
end,
{New_threefold_repetition_rule@2,
Count@1}
end,
New_status@1 = case New_status of
{some,
{in_progress,
Fifty_move_rule@1,
_}} ->
case Count@2 of
3 ->
{some,
{draw,
threefold_repetition}};
_ ->
{some,
{in_progress,
Fifty_move_rule@1,
New_threefold_repetition_rule@3}}
end;
_ ->
New_status
end,
{ok,
New_status@1};
{some,
_} ->
{error,
<<"game is over, unable to apply moves to board"/utf8>>}
end
end
);
{castle, _, _} ->
case erlang:element(
5,
Game
) of
none ->
{ok, none};
{some,
{in_progress,
Fifty_move_rule@2,
Threefold_repetition_rule@1}} ->
New_fifty_move_rule@1 = Fifty_move_rule@2
+ 1,
case (New_fifty_move_rule@1
div 2)
+ 1 of
50 ->
{ok,
{some,
{draw,
fifty_move_rule}}};
_ ->
{ok,
{some,
{in_progress,
New_fifty_move_rule@1,
Threefold_repetition_rule@1}}}
end;
{some, _} ->
erlang:error(
#{gleam_error => panic,
message => <<"game is over, unable to apply moves to board"/utf8>>,
module => <<"game"/utf8>>,
function => <<"apply_move"/utf8>>,
line => 3952}
)
end;
{en_passant, _, _} ->
case erlang:element(
5,
Game
) of
none ->
{ok, none};
{some,
{in_progress,
_,
Threefold_repetition_rule@2}} ->
{ok,
{some,
{in_progress,
0,
Threefold_repetition_rule@2}}};
{some, _} ->
{error,
<<"game is over, unable to apply moves to board"/utf8>>}
end
end,
gleam@result:'try'(
New_status@2,
fun(New_status@3) ->
New_game_state@5 = erlang:setelement(
5,
New_game_state@4,
New_status@3
),
{ok,
New_game_state@5}
end
);
[false, true] ->
New_status@2 = case Move of
{normal, From, To, _} ->
gleam@result:'try'(
case board:get_piece_at_position(
erlang:element(
2,
Game
),
From
) of
{some,
Piece} ->
{ok,
Piece};
none ->
{error,
<<"no piece at from position"/utf8>>}
end,
fun(
Moving_piece
) ->
case erlang:element(
5,
Game
) of
none ->
{ok,
none};
{some,
{in_progress,
Fifty_move_rule,
Threefold_repetition_rule}} ->
Captured_piece = piece_at_position(
Game,
To
),
New_fifty_move_rule = case Captured_piece of
{some,
_} ->
0;
none ->
case Moving_piece of
{piece,
_,
pawn} ->
0;
_ ->
Fifty_move_rule
+ 1
end
end,
New_status = case (New_fifty_move_rule
div 2)
+ 1 of
50 ->
{some,
{draw,
fifty_move_rule}};
_ ->
{some,
{in_progress,
New_fifty_move_rule,
Threefold_repetition_rule}}
end,
{New_threefold_repetition_rule@3,
Count@2} = case Captured_piece of
{some,
_} ->
{Threefold_repetition_rule,
0};
none ->
New_threefold_position = {three_fold_position,
erlang:element(
3,
Game
),
erlang:element(
2,
Game
),
erlang:element(
11,
Game
),
erlang:element(
7,
Game
),
erlang:element(
8,
Game
),
erlang:element(
9,
Game
),
erlang:element(
10,
Game
)},
{New_threefold_repetition_rule@2,
Count@1} = case gleam@dict:get(
Threefold_repetition_rule,
New_threefold_position
) of
{error,
_} ->
New_threefold_repetition_rule = gleam@dict:insert(
Threefold_repetition_rule,
New_threefold_position,
1
),
{New_threefold_repetition_rule,
1};
{ok,
Count} ->
New_threefold_repetition_rule@1 = gleam@dict:insert(
Threefold_repetition_rule,
New_threefold_position,
Count
+ 1
),
{New_threefold_repetition_rule@1,
Count
+ 1}
end,
{New_threefold_repetition_rule@2,
Count@1}
end,
New_status@1 = case New_status of
{some,
{in_progress,
Fifty_move_rule@1,
_}} ->
case Count@2 of
3 ->
{some,
{draw,
threefold_repetition}};
_ ->
{some,
{in_progress,
Fifty_move_rule@1,
New_threefold_repetition_rule@3}}
end;
_ ->
New_status
end,
{ok,
New_status@1};
{some,
_} ->
{error,
<<"game is over, unable to apply moves to board"/utf8>>}
end
end
);
{castle, _, _} ->
case erlang:element(
5,
Game
) of
none ->
{ok, none};
{some,
{in_progress,
Fifty_move_rule@2,
Threefold_repetition_rule@1}} ->
New_fifty_move_rule@1 = Fifty_move_rule@2
+ 1,
case (New_fifty_move_rule@1
div 2)
+ 1 of
50 ->
{ok,
{some,
{draw,
fifty_move_rule}}};
_ ->
{ok,
{some,
{in_progress,
New_fifty_move_rule@1,
Threefold_repetition_rule@1}}}
end;
{some, _} ->
erlang:error(
#{gleam_error => panic,
message => <<"game is over, unable to apply moves to board"/utf8>>,
module => <<"game"/utf8>>,
function => <<"apply_move"/utf8>>,
line => 3952}
)
end;
{en_passant, _, _} ->
case erlang:element(
5,
Game
) of
none ->
{ok, none};
{some,
{in_progress,
_,
Threefold_repetition_rule@2}} ->
{ok,
{some,
{in_progress,
0,
Threefold_repetition_rule@2}}};
{some, _} ->
{error,
<<"game is over, unable to apply moves to board"/utf8>>}
end
end,
gleam@result:'try'(
New_status@2,
fun(New_status@3) ->
New_game_state@5 = erlang:setelement(
5,
New_game_state@4,
New_status@3
),
{ok,
New_game_state@5}
end
);
[false, false] ->
{ok,
erlang:setelement(
5,
New_game_state@4,
{some,
{draw,
stalemate}}
)};
_ ->
{error,
<<"This panic should be unreachable"/utf8>>}
end,
New_game_state@6
end
)
end
)
end
)
end
);
{some, _} ->
{error, <<"Game is over, unable to apply moves to board"/utf8>>}
end.
-spec apply_move_san_string(game(), binary()) -> {ok, game()} |
{error, binary()}.
apply_move_san_string(Game, Move) ->
Move_san = move_san:from_string(Move),
case Move_san of
{ok, Move_san@1} ->
case Move_san@1 of
{normal, _, To, Moving_piece, _, Promotion, _} ->
Promotion@2 = case Promotion of
{some, Promotion@1} ->
{some,
{piece, erlang:element(3, Game), Promotion@1}};
none ->
none
end,
Move@5 = (gleam@result:'try'(
all_legal_moves(Game),
fun(All_legal_moves_ok) ->
Potential_moves = gleam@list:filter(
All_legal_moves_ok,
fun(Move@1) -> case Move@1 of
{normal, _, To_legal, Promo_legal} when (To_legal =:= To) andalso (Promo_legal =:= Promotion@2) ->
true;
_ ->
false
end end
),
case Potential_moves of
[] ->
{error, <<"No potential moves found"/utf8>>};
[Move@2] ->
case Move@2 of
{normal, _, _, _} ->
{ok, Move@2};
_ ->
erlang:error(#{gleam_error => panic,
message => <<"This panic should be unreachable"/utf8>>,
module => <<"game"/utf8>>,
function => <<"apply_move_san_string"/utf8>>,
line => 4032})
end;
Move_list ->
Maybe_move = gleam@list:filter(
Move_list,
fun(Move@3) -> case Move@3 of
{normal, From, _, _} ->
case board:get_piece_at_position(
erlang:element(2, Game),
From
) of
{some, Piece} ->
erlang:element(
3,
Piece
)
=:= Moving_piece;
none ->
false
end;
_ ->
false
end end
),
case Maybe_move of
[] ->
{error, <<"Move not found"/utf8>>};
[Move@4] ->
{ok, Move@4};
_ ->
erlang:error(#{gleam_error => panic,
message => <<"This panic should be unreachable"/utf8>>,
module => <<"game"/utf8>>,
function => <<"apply_move_san_string"/utf8>>,
line => 4056})
end
end
end
)),
case Move@5 of
{ok, Move@6} ->
New_game_state = apply_move(Game, Move@6),
New_game_state;
{error, Error} ->
{error, Error}
end;
{castle, Side, _} ->
Move@7 = case Side of
king_side ->
case erlang:element(3, Game) of
white ->
{castle,
{position, e, one},
{position, g, one}};
black ->
{castle,
{position, e, eight},
{position, g, eight}}
end;
queen_side ->
case erlang:element(3, Game) of
white ->
{castle,
{position, e, one},
{position, c, one}};
black ->
{castle,
{position, e, eight},
{position, c, eight}}
end
end,
apply_move(Game, Move@7);
{en_passant, From@1, To@1, _} ->
gleam@result:'try'(
all_legal_moves(Game),
fun(All_legal_moves_ok@1) ->
Ep_moves = gleam@list:filter(
All_legal_moves_ok@1,
fun(Move@8) -> case Move@8 of
{en_passant, _, To_legal@1} when To_legal@1 =:= To@1 ->
true;
_ ->
false
end end
),
case Ep_moves of
[] ->
{error, <<"Illegal move"/utf8>>};
[Move@9] ->
apply_move(Game, Move@9);
[Move_1, Move_2] ->
case From@1 of
{some, {position_san, {some, File}, _}} when File =:= erlang:element(
2,
erlang:element(2, Move_1)
) ->
apply_move(Game, Move_1);
{some,
{position_san, {some, File@1}, _}} when File@1 =:= erlang:element(
2,
erlang:element(2, Move_2)
) ->
apply_move(Game, Move_2);
_ ->
{error, <<"Illegal move"/utf8>>}
end;
_ ->
{error, <<"Illegal move"/utf8>>}
end
end
)
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end.
-spec load_pgn(binary()) -> {ok, game()} | {error, binary()}.
load_pgn(Pgn) ->
Game = new_game(),
Pgn@1 = gleam@string:trim(Pgn),
Pgn@2 = pgn:remove_tags(Pgn@1),
List_of_movetext = pgn:split_movetext(Pgn@2),
gleam@list:fold(
List_of_movetext,
{ok, Game},
fun(Game@1, Movetext) ->
gleam@result:'try'(
Game@1,
fun(Game@2) ->
Game@6 = case gleam@string:split(Movetext, <<" "/utf8>>) of
[White_ply, Black_ply] ->
Game@3 = apply_move_san_string(Game@2, White_ply),
case Game@3 of
{ok, Game@4} ->
apply_move_san_string(Game@4, Black_ply);
{error, Message} ->
{error, Message}
end;
[White_ply@1] ->
Game@5 = apply_move_san_string(Game@2, White_ply@1),
Game@5;
[] ->
{error, <<"Invalid PGN"/utf8>>};
_ ->
{error, <<"Invalid PGN"/utf8>>}
end,
Game@6
end
)
end
).
-spec apply_move_uci(game(), binary()) -> {ok, game()} | {error, binary()}.
apply_move_uci(Game, Move) ->
case erlang:element(5, Game) of
{some, {in_progress, _, _}} ->
case gleam@string:length(Move) of
4 ->
Move_chars = gleam@string:to_graphemes(Move),
From_file = case gleam@list:first(Move_chars) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error, <<"Could not parse origin file"/utf8>>}
end,
case gleam@list:rest(Move_chars) of
{ok, Move_chars@1} ->
From_rank = case gleam@list:first(Move_chars@1) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse origin rank"/utf8>>}
end,
case gleam@list:rest(Move_chars@1) of
{ok, Move_chars@2} ->
To_file = case gleam@list:first(
Move_chars@2
) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error,
<<"Could not parse destination file"/utf8>>}
end,
case gleam@list:rest(Move_chars@2) of
{ok, Move_chars@3} ->
To_rank = case gleam@list:first(
Move_chars@3
) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse destination rank"/utf8>>}
end,
case {From_file,
From_rank,
To_file,
To_rank} of
{{ok, From_file@1},
{ok, From_rank@1},
{ok, To_file@1},
{ok, To_rank@1}} ->
Promo = case gleam@string:slice(
Move,
4,
1
) of
<<"q"/utf8>> ->
{some, queen};
<<"r"/utf8>> ->
{some, rook};
<<"b"/utf8>> ->
{some, bishop};
<<"n"/utf8>> ->
{some, knight};
_ ->
none
end,
gleam@result:'try'(
case piece_at_position(
Game,
{position,
From_file@1,
From_rank@1}
) of
{some, Piece} ->
{ok, Piece};
none ->
{error,
<<"No piece at origin"/utf8>>}
end,
fun(Piece@1) ->
Maybe_enemy_piece = piece_at_position(
Game,
{position,
To_file@1,
To_rank@1}
),
Move@1 = case Promo of
{some, Promo@1} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
{some,
{piece,
erlang:element(
3,
Game
),
Promo@1}}};
none ->
case Piece@1 of
{piece,
_,
pawn} ->
case From_file@1
=:= To_file@1 of
true ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
false ->
case Maybe_enemy_piece of
{some,
_} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
none ->
{en_passant,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1}}
end
end;
{piece,
_,
king} ->
case position:file_to_int(
From_file@1
)
- position:file_to_int(
To_file@1
) of
2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
-2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end;
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end
end,
New_game_state = apply_move(
Game,
Move@1
),
New_game_state
end
);
{From_file_result,
From_rank_result,
To_file_result,
To_rank_result} ->
{_, File_errors} = gleam@result:partition(
[From_file_result,
To_file_result]
),
{_, Rank_errors} = gleam@result:partition(
[From_rank_result,
To_rank_result]
),
Errors = gleam@list:concat(
[File_errors,
Rank_errors]
),
{error,
gleam@string:join(
Errors,
<<", "/utf8>>
)}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
5 ->
Move_chars = gleam@string:to_graphemes(Move),
From_file = case gleam@list:first(Move_chars) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error, <<"Could not parse origin file"/utf8>>}
end,
case gleam@list:rest(Move_chars) of
{ok, Move_chars@1} ->
From_rank = case gleam@list:first(Move_chars@1) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse origin rank"/utf8>>}
end,
case gleam@list:rest(Move_chars@1) of
{ok, Move_chars@2} ->
To_file = case gleam@list:first(
Move_chars@2
) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error,
<<"Could not parse destination file"/utf8>>}
end,
case gleam@list:rest(Move_chars@2) of
{ok, Move_chars@3} ->
To_rank = case gleam@list:first(
Move_chars@3
) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse destination rank"/utf8>>}
end,
case {From_file,
From_rank,
To_file,
To_rank} of
{{ok, From_file@1},
{ok, From_rank@1},
{ok, To_file@1},
{ok, To_rank@1}} ->
Promo = case gleam@string:slice(
Move,
4,
1
) of
<<"q"/utf8>> ->
{some, queen};
<<"r"/utf8>> ->
{some, rook};
<<"b"/utf8>> ->
{some, bishop};
<<"n"/utf8>> ->
{some, knight};
_ ->
none
end,
gleam@result:'try'(
case piece_at_position(
Game,
{position,
From_file@1,
From_rank@1}
) of
{some, Piece} ->
{ok, Piece};
none ->
{error,
<<"No piece at origin"/utf8>>}
end,
fun(Piece@1) ->
Maybe_enemy_piece = piece_at_position(
Game,
{position,
To_file@1,
To_rank@1}
),
Move@1 = case Promo of
{some, Promo@1} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
{some,
{piece,
erlang:element(
3,
Game
),
Promo@1}}};
none ->
case Piece@1 of
{piece,
_,
pawn} ->
case From_file@1
=:= To_file@1 of
true ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
false ->
case Maybe_enemy_piece of
{some,
_} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
none ->
{en_passant,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1}}
end
end;
{piece,
_,
king} ->
case position:file_to_int(
From_file@1
)
- position:file_to_int(
To_file@1
) of
2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
-2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end;
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end
end,
New_game_state = apply_move(
Game,
Move@1
),
New_game_state
end
);
{From_file_result,
From_rank_result,
To_file_result,
To_rank_result} ->
{_, File_errors} = gleam@result:partition(
[From_file_result,
To_file_result]
),
{_, Rank_errors} = gleam@result:partition(
[From_rank_result,
To_rank_result]
),
Errors = gleam@list:concat(
[File_errors,
Rank_errors]
),
{error,
gleam@string:join(
Errors,
<<", "/utf8>>
)}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
none ->
case gleam@string:length(Move) of
4 ->
Move_chars = gleam@string:to_graphemes(Move),
From_file = case gleam@list:first(Move_chars) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error, <<"Could not parse origin file"/utf8>>}
end,
case gleam@list:rest(Move_chars) of
{ok, Move_chars@1} ->
From_rank = case gleam@list:first(Move_chars@1) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse origin rank"/utf8>>}
end,
case gleam@list:rest(Move_chars@1) of
{ok, Move_chars@2} ->
To_file = case gleam@list:first(
Move_chars@2
) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error,
<<"Could not parse destination file"/utf8>>}
end,
case gleam@list:rest(Move_chars@2) of
{ok, Move_chars@3} ->
To_rank = case gleam@list:first(
Move_chars@3
) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse destination rank"/utf8>>}
end,
case {From_file,
From_rank,
To_file,
To_rank} of
{{ok, From_file@1},
{ok, From_rank@1},
{ok, To_file@1},
{ok, To_rank@1}} ->
Promo = case gleam@string:slice(
Move,
4,
1
) of
<<"q"/utf8>> ->
{some, queen};
<<"r"/utf8>> ->
{some, rook};
<<"b"/utf8>> ->
{some, bishop};
<<"n"/utf8>> ->
{some, knight};
_ ->
none
end,
gleam@result:'try'(
case piece_at_position(
Game,
{position,
From_file@1,
From_rank@1}
) of
{some, Piece} ->
{ok, Piece};
none ->
{error,
<<"No piece at origin"/utf8>>}
end,
fun(Piece@1) ->
Maybe_enemy_piece = piece_at_position(
Game,
{position,
To_file@1,
To_rank@1}
),
Move@1 = case Promo of
{some, Promo@1} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
{some,
{piece,
erlang:element(
3,
Game
),
Promo@1}}};
none ->
case Piece@1 of
{piece,
_,
pawn} ->
case From_file@1
=:= To_file@1 of
true ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
false ->
case Maybe_enemy_piece of
{some,
_} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
none ->
{en_passant,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1}}
end
end;
{piece,
_,
king} ->
case position:file_to_int(
From_file@1
)
- position:file_to_int(
To_file@1
) of
2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
-2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end;
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end
end,
New_game_state = apply_move(
Game,
Move@1
),
New_game_state
end
);
{From_file_result,
From_rank_result,
To_file_result,
To_rank_result} ->
{_, File_errors} = gleam@result:partition(
[From_file_result,
To_file_result]
),
{_, Rank_errors} = gleam@result:partition(
[From_rank_result,
To_rank_result]
),
Errors = gleam@list:concat(
[File_errors,
Rank_errors]
),
{error,
gleam@string:join(
Errors,
<<", "/utf8>>
)}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
5 ->
Move_chars = gleam@string:to_graphemes(Move),
From_file = case gleam@list:first(Move_chars) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error, <<"Could not parse origin file"/utf8>>}
end,
case gleam@list:rest(Move_chars) of
{ok, Move_chars@1} ->
From_rank = case gleam@list:first(Move_chars@1) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse origin rank"/utf8>>}
end,
case gleam@list:rest(Move_chars@1) of
{ok, Move_chars@2} ->
To_file = case gleam@list:first(
Move_chars@2
) of
{ok, <<"a"/utf8>>} ->
{ok, a};
{ok, <<"b"/utf8>>} ->
{ok, b};
{ok, <<"c"/utf8>>} ->
{ok, c};
{ok, <<"d"/utf8>>} ->
{ok, d};
{ok, <<"e"/utf8>>} ->
{ok, e};
{ok, <<"f"/utf8>>} ->
{ok, f};
{ok, <<"g"/utf8>>} ->
{ok, g};
{ok, <<"h"/utf8>>} ->
{ok, h};
_ ->
{error,
<<"Could not parse destination file"/utf8>>}
end,
case gleam@list:rest(Move_chars@2) of
{ok, Move_chars@3} ->
To_rank = case gleam@list:first(
Move_chars@3
) of
{ok, <<"1"/utf8>>} ->
{ok, one};
{ok, <<"2"/utf8>>} ->
{ok, two};
{ok, <<"3"/utf8>>} ->
{ok, three};
{ok, <<"4"/utf8>>} ->
{ok, four};
{ok, <<"5"/utf8>>} ->
{ok, five};
{ok, <<"6"/utf8>>} ->
{ok, six};
{ok, <<"7"/utf8>>} ->
{ok, seven};
{ok, <<"8"/utf8>>} ->
{ok, eight};
_ ->
{error,
<<"Could not parse destination rank"/utf8>>}
end,
case {From_file,
From_rank,
To_file,
To_rank} of
{{ok, From_file@1},
{ok, From_rank@1},
{ok, To_file@1},
{ok, To_rank@1}} ->
Promo = case gleam@string:slice(
Move,
4,
1
) of
<<"q"/utf8>> ->
{some, queen};
<<"r"/utf8>> ->
{some, rook};
<<"b"/utf8>> ->
{some, bishop};
<<"n"/utf8>> ->
{some, knight};
_ ->
none
end,
gleam@result:'try'(
case piece_at_position(
Game,
{position,
From_file@1,
From_rank@1}
) of
{some, Piece} ->
{ok, Piece};
none ->
{error,
<<"No piece at origin"/utf8>>}
end,
fun(Piece@1) ->
Maybe_enemy_piece = piece_at_position(
Game,
{position,
To_file@1,
To_rank@1}
),
Move@1 = case Promo of
{some, Promo@1} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
{some,
{piece,
erlang:element(
3,
Game
),
Promo@1}}};
none ->
case Piece@1 of
{piece,
_,
pawn} ->
case From_file@1
=:= To_file@1 of
true ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
false ->
case Maybe_enemy_piece of
{some,
_} ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none};
none ->
{en_passant,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1}}
end
end;
{piece,
_,
king} ->
case position:file_to_int(
From_file@1
)
- position:file_to_int(
To_file@1
) of
2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
-2 ->
{castle,
{position,
e,
From_rank@1},
{position,
To_file@1,
To_rank@1}};
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end;
_ ->
{normal,
{position,
From_file@1,
From_rank@1},
{position,
To_file@1,
To_rank@1},
none}
end
end,
New_game_state = apply_move(
Game,
Move@1
),
New_game_state
end
);
{From_file_result,
From_rank_result,
To_file_result,
To_rank_result} ->
{_, File_errors} = gleam@result:partition(
[From_file_result,
To_file_result]
),
{_, Rank_errors} = gleam@result:partition(
[From_rank_result,
To_rank_result]
),
Errors = gleam@list:concat(
[File_errors,
Rank_errors]
),
{error,
gleam@string:join(
Errors,
<<", "/utf8>>
)}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
{error, _} ->
{error, <<"Invalid move"/utf8>>}
end;
_ ->
{error, <<"Invalid move"/utf8>>}
end;
{some, _} ->
{ok, Game}
end.