-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