+extends Control

+class_name Grid

+

+const PieceScene := preload("res://piece/Piece.tscn")

+const Square := preload("res://Square.tscn")

+

+### for the sandisplay

+signal add_to_pgn(move)

+signal clear_pgn

+signal load_pgn(moves)

+signal remove_last

+

+var move_indicators: PoolIntArray = []

+

+var rot: float = 0

+var piece_size: Vector2

+

+export(Color) var overlay_color: Color

+export(Color) var premove_color: Color

+export(Color) var last_move_indicator_color: Color

+export(Color) var last_move_take_indicator: Color

+export(Color) var clockrunning_color: Color

+export(Color) var clockrunninglow: Color

+export(Color) var clocklow: Color

+

+var board = [] # has `get_piece(algebraic position)` and `set_piece(algebraic position)` for ease of use

+

+

+func get_piece(alg: String) -> Piece:

+ return board[Chess.SQUARE_MAP[alg]]

+

+

+func set_piece(alg: String, p: Piece) -> void:

+ board[Chess.SQUARE_MAP[alg]] = p

+

+

+var flipped := false

+var labels := {numbers = [], letters = []}

+var background_array := []

+var last_clicked: Piece

+var premove: Dictionary = {}

+var check_circle: GradientTexture2D = load("res://piece/check-circle.tres")

+var take_circle: GradientTexture2D = load("res://piece/takeable-circle.tres")

+var move_circle: GradientTexture2D = load("res://piece/move-circle.tres")

+

+onready var game: GameUI = owner if owner is GameUI else null

+onready var sidebar := game.get_node_or_null("%Sidebar") if game else null

+onready var darken = $Darken

+onready var foreground := $Foreground

+onready var background := $Background

+onready var pieces := $Pieces

+onready var arrows := $"%Arrows"

+

+var chess := Chess.new()

+var local := false

+var spectating := false

+var team: String

+var auto_change_team := false

+

+

+func _init():

+ Globals.grid = self

+

+

+func _exit_tree():

+ Globals.grid = null

+

+

+func _process(_delta):

+ rect_rotation = rot

+ foreground.rect_rotation = rot

+ if Input.is_action_just_pressed("debug") and Debug.debug:

+ print(chess.ascii())

+

+

+func _resized():

+ var old_pc = piece_size

+ piece_size = rect_size / 8

+ piece_size.x = clamp(piece_size.x, 0, piece_size.y)

+ piece_size.y = clamp(piece_size.y, 0, piece_size.x)

+ check_circle.width = piece_size.x

+ check_circle.height = piece_size.y

+ take_circle.width = piece_size.x

+ take_circle.height = piece_size.y

+ move_circle.width = piece_size.x

+ move_circle.height = piece_size.y

+ if foreground:

+ rect_pivot_offset = (piece_size * 8) / 2

+ foreground.rect_pivot_offset = rect_pivot_offset

+ if not (board.empty() && background_array.empty()) && piece_size != old_pc:

+ resize_board()

+ Log.debug("Resizing board")

+

+

+func set_take_move_circle_color(

+ color: Color = Color(overlay_color.r, overlay_color.g, overlay_color.b, .65)

+) -> void:

+ take_circle.gradient.colors[1] = color

+ move_circle.gradient.colors[0] = color

+

+

+func _ready():

+ set_take_move_circle_color()

+ _resized()

+ Events.connect("turn_over", self, "_on_turn_over")

+ PacketHandler.connect("move_data", self, "move", [false, false])

+ create_pieces()

+ create_squares()

+ create_labels()

+ yield(get_tree(), "idle_frame")

+ if !team:

+ team = chess.turn

+ auto_change_team = true

+ Log.debug("board: ready")

+

+

+func resize_board():

+ resize_pieces()

+

+

+func create_squares() -> void: # create the board

+ background_array.resize(128)

+ for i in Chess.SQUARE_MAP.values():

+ var alg := Chess.algebraic(i)

+ var square := Square.instance() # create a square

+ square.name = alg

+ square.b = self

+ square.square = alg

+ square.hint_tooltip = alg

+ square.color = (Globals.board_color1 if Chess.square_color(alg) == "light" else Globals.board_color2) # set the color

+ background.add_child(square) # add the square to the background

+ square.connect("clicked", self, "square_clicked", [square]) # connect the clicked event

+ background_array[i] = square # add the square to the background array

+ arrows._setup(self) # initialize the arrows

+

+

+func create_labels() -> void:

+ var font: DynamicFont = load("res://ui/ubuntu-bold-regular.tres").duplicate()

+ font.size = 15

+ for k in Chess.SQUARE_MAP:

+ if k == "h1":

+ var l = init_label(font, k, k[0], VALIGN_BOTTOM, 0, false)

+ var n = init_label(font, k, k[1], 0, VALIGN_BOTTOM, false)

+ var h = HBoxContainer.new()

+ h.mouse_filter = MOUSE_FILTER_IGNORE

+ for i in [l, n]:

+ var ic = create_margin_container()

+ ic.add_child(i)

+ h.add_child(ic)

+ labels.numbers.append(n)

+ labels.letters.append(l)

+ foreground.add_child(h)

+ elif k[0] == "h": # file h contains numbers

+ labels.numbers.append(init_label(font, k, k[1], 0, VALIGN_BOTTOM))

+ elif k[1] == "1": # rank 1 contains letters

+ labels.letters.append(init_label(font, k, k[0], VALIGN_BOTTOM))

+ else:

+ var spacer = Control.new()

+ spacer.mouse_filter = MOUSE_FILTER_IGNORE

+ spacer.name = k + "_space"

+ spacer.size_flags_horizontal = SIZE_EXPAND_FILL

+ spacer.size_flags_vertical = SIZE_EXPAND_FILL

+ foreground.add_child(spacer)

+

+

+func init_label(font: DynamicFont, alg: String, text: String, valign := 0, align := 0, add := true) -> Label:

+ var label := Label.new()

+ label.align = align

+ label.valign = valign

+ label.size_flags_horizontal = SIZE_EXPAND_FILL

+ label.size_flags_vertical = SIZE_EXPAND_FILL

+ label.mouse_filter = MOUSE_FILTER_IGNORE

+ label.name = text

+ label.text = text

+ label.add_color_override(

+ "font_color", Globals.board_color1 if Chess.square_color(alg) == "dark" else Globals.board_color2

+ )

+ label.add_font_override("font", font)

+ if add:

+ var container := create_margin_container()

+ container.add_child(label)

+ foreground.add_child(container)

+ return label

+

+

+func create_margin_container(margin := 5) -> MarginContainer:

+ var c := MarginContainer.new()

+ c.add_constant_override("margin_top", margin)

+ c.add_constant_override("margin_left", margin)

+ c.add_constant_override("margin_right", margin)

+ c.add_constant_override("margin_bottom", margin)

+ c.size_flags_horizontal = SIZE_EXPAND_FILL

+ c.size_flags_vertical = SIZE_EXPAND_FILL

+ c.mouse_filter = MOUSE_FILTER_IGNORE

+ return c

+

+

+func clear_pieces() -> void:

+ for i in Chess.SQUARE_MAP.values():

+ var p: Piece = board[i]

+ if p:

+ p.queue_free()

+ board[i] = null

+

+

+func resize_pieces():

+ for i in Chess.SQUARE_MAP.values():

+ var p: Piece = board[i]

+ if p:

+ p.size()

+

+

+func create_pieces():

+ board.resize(128)

+ for k in Chess.SQUARE_MAP:

+ var piece = chess.get(k)

+ if piece:

+ make_piece(k, piece.type, piece.color)

+

+

+func make_piece(algebraic: String, piece_type: String, color := "w") -> void: # make peace

+ var piece := PieceScene.instance() # create a piece

+ piece.name = "%s-%s" % [piece_type, algebraic]

+ piece.b = self

+ piece.position = algebraic

+ piece.type = piece_type

+ piece.color = color

+ pieces.add_child(piece) # add the piece to the grid

+ set_piece(algebraic, piece)

+

+

+func flip_pieces() -> void:

+ for i in Chess.SQUARE_MAP.values():

+ var spot: Piece = board[i]

+ if spot:

+ spot.sprite.flip_v = flipped

+ spot.sprite.flip_h = flipped

+

+

+func flip_labels() -> void:

+ for i in range(8):

+ var numlabel: Label = labels.numbers[i]

+ var letlabel: Label = labels.letters[i]

+ var number := i + 1 if flipped else 8 - i

+ numlabel.text = str(number)

+ letlabel.text = "hgfedcba"[number - 1]

+

+

+func flip_board() -> void:

+ rot = 0 if rot == 180 else 180

+ flipped = rot == 180

+ Log.debug(["Flipped the board, now", "flipped" if flipped else "not flipped"])

+ if sidebar:

+ sidebar.flip_panels()

+ flip_pieces()

+ flip_labels()

+

+

+func is_my_turn() -> bool:

+ return team == chess.turn

+

+

+func square_clicked(clicked_square: BackgroundSquare) -> void:

+ if Globals.spectating:

+ return

+

+ var p := get_piece(clicked_square.square)

+

+ if not is_my_turn() and is_instance_valid(last_clicked):

+ # PREMOVE AREA

+ var p_sq: int = Chess.SQUARE_MAP[clicked_square.square]

+ for m in chess.piece_moves(last_clicked.position, last_clicked.type, team):

+ if m.to == p_sq && m.from == Chess.SQUARE_MAP[last_clicked.position]:

+ if "from" in premove and "to" in premove:

+ background_array[premove.from].premove_indicator.hide() # hide premove indicators

+ background_array[premove.to].premove_indicator.hide()

+ if premove && premove.from == m.from && premove.to == m.to:

+ premove = {}

+ Log.debug("De-selected premove")

+ else:

+ premove = m

+ background_array[premove.from].premove_indicator.show()

+ background_array[premove.to].premove_indicator.show()

+ if premove.flags & Chess.BITS.PROMOTION:

+ p.open_promotion_previews(darken)

+ premove.promotion = yield(p, "promotion_decided")

+ Log.debug("Selected premove: %s" % premove)

+ clear_last_clicked()

+ return

+ elif (!p or p.color != team) and is_instance_valid(last_clicked):

+ # Attempt to make the move (NORMAL MOVE AREA)

+ for m in chess.moves({square = last_clicked.position, verbose = true}):

+ if m.to == clicked_square.square && m.from == last_clicked.position:

+ move(m.san)

+ clear_last_clicked()

+ return

+

+ clear_last_clicked()

+

+ if p and p.color == team:

+ if chess.turn != team:

+ if !Globals.premoves:

+ return

+ clicked_square.show_premove_indicators()

+ else:

+ clicked_square.show_move_indicators()

+ last_clicked = p

+

+

+func move(san: String, send := true, create_promotion_input := true) -> void:

+ var sound_handled = false

+ var move_0x88 = chess.__move_from_san(san, true)

+ var valid_moves = chess.moves({square = chess.algebraic(move_0x88.from), stripped = true})

+ if valid_moves.find(chess.stripped_san(san)) == -1:

+ Log.err("Invalid move " + san)

+ return

+ Log.debug("Making move " + san)

+ chess.__make_move(move_0x88)

+ if move_0x88.flags & Chess.BITS.CAPTURE:

+ board[move_0x88.to].took()

+ SoundFx.play("Capture")

+ sound_handled = true

+ elif move_0x88.flags & Chess.BITS.EP_CAPTURE:

+ var to_take := Chess.offset(move_0x88.to, Vector2(0, 1 * -1 if chess.turn == Chess.WHITE else 1))

+ get_piece(to_take).took()

+ SoundFx.play("Capture")

+ sound_handled = true

+ elif move_0x88.flags & Chess.BITS.KSIDE_CASTLE: # kingside castling

+ var rook_pos := Chess.offset(move_0x88.to, Vector2(1, 0))

+ get_piece(rook_pos).move(Chess.offset(move_0x88.to, Vector2(-1, 0)))

+ elif move_0x88.flags & Chess.BITS.QSIDE_CASTLE: # queenside

+ var rook_pos := Chess.offset(move_0x88.to, Vector2(-2, 0))

+ get_piece(rook_pos).move(Chess.offset(move_0x88.to, Vector2(1, 0)))

+ if move_0x88.flags & Chess.BITS.PROMOTION: #promotion wow

+ var p: Piece = yield(board[move_0x88.from].move(Chess.algebraic(move_0x88.to), true), "completed")

+ if create_promotion_input:

+ p.open_promotion_previews(darken)

+ move_0x88.promotion = yield(p, "promotion_decided")

+ san = chess.__move_to_san(move_0x88) # update the san with new promotion data

+ p.queue_free()

+ else: # was opponents turn, this is opponents move: promotion is already chosen

+ p.queue_free()

+ make_piece(p.position, move_0x88.promotion, p.color)

+ SoundFx.play("Move" if move_0x88.flags & Chess.BITS.NORMAL else "Capture")

+ sound_handled = true

+ else: # not promotion: from **always** moves to `to`

+ var _p = board[move_0x88.from].move(Chess.algebraic(move_0x88.to))

+ if send && !local:

+ PacketHandler.send_mov(san)

+ if !sound_handled:

+ SoundFx.play("Move")

+ emit_signal("add_to_pgn", san)

+ Events.emit_signal("turn_over")

+

+

+func clear_last_clicked():

+ last_clicked = null

+

+

+func draw(reason := "") -> void:

+ var string = "draw by " + reason

+ game.set_status(string, 0)

+ SoundFx.play("Victory")

+ Events.emit_signal("game_over", string)

+

+

+func win(winner: String, reason := "") -> void:

+ var string = "%s won the game by %s" % [Utils.expand_color(winner), reason]

+ game.set_status(string, 0) #: black won the game by checkmate

+ Events.emit_signal("game_over", string)

+ SoundFx.play("Victory")

+

+

+func load_pgn(pgn: String) -> void:

+ chess.load_pgn(pgn, {sloppy = true})

+ clear_pieces()

+ create_pieces()

+ emit_signal("clear_pgn")

+ var pgn_parser := PGN.new()

+ var movs: PoolStringArray = pgn_parser.parse(pgn).moves

+ emit_signal("load_pgn", movs)

+ Log.info("load pgn " + pgn)

+ Events.emit_signal("turn_over")

+

+

+func undo(two: bool = false) -> void:

+ Globals.chat.server("undid move %s" % chess.undo().san)

+ emit_signal("remove_last")

+ if two:

+ Globals.chat.server("undid move %s" % chess.undo().san)

+ emit_signal("remove_last")

+ clear_pieces()

+ clear_last_clicked()

+ create_pieces()

+ Events.emit_signal("turn_over")

+

+

+func auto_flip():

+ if team == Chess.WHITE and flipped:

+ flip_board()

+ elif team == Chess.BLACK and not flipped:

+ flip_board()

+

+

+func _on_turn_over():

+ # if auto_change_team:

+ # team = chess.turn

+ # auto_flip()

+

+ if is_my_turn():

+ set_take_move_circle_color()

+ # use the premove if possible

+ if premove:

+ background_array[premove.from].premove_indicator.hide()

+ background_array[premove.to].premove_indicator.hide()

+ if board[premove.from]: # see if its valid

+ if premove.flags & (Chess.BITS.CAPTURE | Chess.BITS.EP_CAPTURE) && not board[premove.to]:

+ return

+ var san = chess.__move_to_san(premove, chess.__generate_moves({legal = true}), false)

+ if san:

+ var legal_moves = chess.moves({square = chess.algebraic(premove.from), stripped = true})

+ var is_possible_move = legal_moves.find(chess.stripped_san(san)) != -1

+ if chess.__move_from_san(san, true) and (is_possible_move): # it is valid

+ Log.debug(["Executing premove:", san])

+ move(san, true, false) # make the move, send it to the opponent, dont prompt for premoves

+ premove = {}

+ elif Globals.premoves:

+ set_take_move_circle_color(premove_color)

+ SaveLoad.save("user://game.json", {pgn = chess.pgn(), fen = chess.fen()})

+ clear_last_clicked()

+ check_game_over()

+ create_last_move_indicators()

+

+

+func check_game_over():

+ if chess.in_checkmate():

+ # they won if its my turn, i won if its their turn.

+ win(team if is_my_turn() else Chess.__swap_color(team), "checkmate")

+ elif chess.half_moves >= 50:

+ draw("fifty move rule")

+ elif chess.in_stalemate():

+ draw("stalemate")

+ elif chess.insufficient_material():

+ draw("insufficient material")

+ elif chess.in_threefold_repetition():

+ draw("threefold repetition")

+

+

+func create_last_move_indicators():

+ for i in move_indicators:

+ background_array[i].move_indicator.color = last_move_indicator_color

+ background_array[i].move_indicator.hide()

+ if !chess.__history:

+ return

+ var m: Dictionary = chess.__history[-1].move

+ background_array[m.from].move_indicator.show()

+ if m.flags & Chess.BITS.CAPTURE:

+ background_array[m.to].move_indicator.color = last_move_take_indicator

+ background_array[m.to].move_indicator.show()

+ move_indicators = [m.from, m.to]

+

+

+func reload():

+ premove = {}

+ chess = Chess.new()

+ clear_last_clicked()

+ clear_pieces()

+ create_pieces()

+ create_last_move_indicators() # it hides the indicators :/

+ Events.emit_signal("turn_over")

+ emit_signal("clear_pgn") # clears the san displays