202 lines
7.2 KiB
GDScript
202 lines
7.2 KiB
GDScript
@tool
|
|
extends Pawn
|
|
class_name Knight
|
|
func _ready():
|
|
self.texture = load("res://addons/Chess/Textures/WKnight.svg")
|
|
Points = 3
|
|
|
|
func _process(_delta):
|
|
if Item_Color != Temp_Color:
|
|
Temp_Color = Item_Color
|
|
if Item_Color == 0:
|
|
self.texture = load("res://addons/Chess/Textures/WKnight.svg")
|
|
elif Item_Color == 1:
|
|
self.texture = load("res://addons/Chess/Textures/BKnight.svg")
|
|
|
|
func getValidMoves(board_flow, current_location: String) -> Dictionary:
|
|
var moves = {
|
|
"regular_moves": [],
|
|
"special_moves": []
|
|
}
|
|
|
|
var loc = current_location.split("-")
|
|
var x = int(loc[0])
|
|
var y = int(loc[1])
|
|
game = board_flow.get_parent() as ChessGame
|
|
|
|
# All possible L-shaped moves
|
|
var knight_moves = [
|
|
[-2, -1], [-2, 1],
|
|
[-1, -2], [-1, 2],
|
|
[1, -2], [1, 2],
|
|
[2, -1], [2, 1]
|
|
]
|
|
|
|
for move in knight_moves:
|
|
var target_x = x + move[0]
|
|
var target_y = y + move[1]
|
|
var new_loc = str(target_x) + "-" + str(target_y)
|
|
|
|
if is_valid_cell(board_flow, new_loc):
|
|
# Check both possible paths to the target
|
|
var horizontal_first_clear = true
|
|
var vertical_first_clear = true
|
|
|
|
# Path 1: Check horizontal first, then vertical
|
|
# Check horizontal movement
|
|
var step_x = sign(move[0])
|
|
for i in range(1, abs(move[0]) + 1):
|
|
var path_tile_loc = str(x + (i * step_x)) + "-" + str(y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
horizontal_first_clear = false
|
|
break
|
|
|
|
# Check vertical movement if horizontal was clear
|
|
if horizontal_first_clear:
|
|
var step_y = sign(move[1])
|
|
var path_tile_loc = str(target_x) + "-" + str(y + step_y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
horizontal_first_clear = false
|
|
|
|
# Path 2: Check vertical first, then horizontal
|
|
# Check vertical movement
|
|
var step_y = sign(move[1])
|
|
for i in range(1, abs(move[1]) + 1):
|
|
var path_tile_loc = str(x) + "-" + str(y + (i * step_y))
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
vertical_first_clear = false
|
|
break
|
|
|
|
# Check horizontal movement if vertical was clear
|
|
if vertical_first_clear:
|
|
var path_tile_loc = str(x + step_x) + "-" + str(target_y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
vertical_first_clear = false
|
|
|
|
# Move is valid if EITHER path is clear
|
|
if (horizontal_first_clear || vertical_first_clear) && (can_move_to_cell(board_flow, new_loc) || can_move_to_cell(board_flow, new_loc, true)):
|
|
moves.regular_moves.append(new_loc)
|
|
|
|
return moves
|
|
|
|
|
|
# func animate_movement(target_position: Vector2, duration: float = 0.5) -> void:
|
|
# z_index = 1
|
|
# var tween = create_tween()
|
|
# tween.set_trans(Tween.TRANS_LINEAR)
|
|
# tween.set_ease(Tween.EASE_IN_OUT)
|
|
|
|
# var start_pos = global_position
|
|
# var total_delta = target_position - start_pos
|
|
# var mid_pos: Vector2
|
|
|
|
# var game = get_tree().get_first_node_in_group("ChessGame") as ChessGame
|
|
# var cell_delta_x = int(total_delta.x / game.boardXSize)
|
|
# var cell_delta_y = int(total_delta.y / game.boardYSize)
|
|
|
|
# if abs(cell_delta_x) > abs(cell_delta_y):
|
|
# # Moving more horizontally ([-2, ±1])
|
|
# mid_pos = Vector2(
|
|
# start_pos.x + (cell_delta_x * game.boardXSize),
|
|
# start_pos.y
|
|
# )
|
|
# else:
|
|
# # Moving more vertically ([±1, -2])
|
|
# mid_pos = Vector2(
|
|
# start_pos.x,
|
|
# start_pos.y + (cell_delta_y * game.boardYSize)
|
|
# )
|
|
|
|
# # First move (longer distance)
|
|
# tween.tween_property(self, "global_position", mid_pos, duration / 3 * 2)
|
|
# # Second move (shorter distance)
|
|
# tween.tween_property(self, "global_position", target_position, duration / 3 * 1)
|
|
|
|
# await tween.finished
|
|
# z_index = 0
|
|
|
|
|
|
func animate_movement(target_position: Vector2, duration: float = 0.5) -> void:
|
|
z_index = 1
|
|
var tween = create_tween()
|
|
tween.set_trans(Tween.TRANS_LINEAR)
|
|
tween.set_ease(Tween.EASE_IN_OUT)
|
|
|
|
var start_pos = global_position
|
|
var total_delta = target_position - start_pos
|
|
var mid_pos: Vector2
|
|
|
|
var cell_delta_x = int(total_delta.x / game.boardXSize)
|
|
var cell_delta_y = int(total_delta.y / game.boardYSize)
|
|
|
|
# Convert current and target positions to board coordinates
|
|
var current_x = int(start_pos.x / game.boardXSize)
|
|
var current_y = int(start_pos.y / game.boardYSize)
|
|
|
|
# Check both possible paths
|
|
var horizontal_first_clear = true
|
|
var vertical_first_clear = true
|
|
|
|
# Check horizontal-first path
|
|
for i in range(1, abs(cell_delta_x) + 1):
|
|
var step_x = sign(cell_delta_x)
|
|
var path_tile_loc = str(current_x + (i * step_x)) + "-" + str(current_y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
horizontal_first_clear = false
|
|
break
|
|
|
|
if horizontal_first_clear:
|
|
var step_y = sign(cell_delta_y)
|
|
var path_tile_loc = str(current_x + cell_delta_x) + "-" + str(current_y + step_y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
horizontal_first_clear = false
|
|
|
|
# Check vertical-first path
|
|
for i in range(1, abs(cell_delta_y) + 1):
|
|
var step_y = sign(cell_delta_y)
|
|
var path_tile_loc = str(current_x) + "-" + str(current_y + (i * step_y))
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
vertical_first_clear = false
|
|
break
|
|
|
|
if vertical_first_clear:
|
|
var step_x = sign(cell_delta_x)
|
|
var path_tile_loc = str(current_x + step_x) + "-" + str(current_y + cell_delta_y)
|
|
var tile = game.tileManager.get_tile(path_tile_loc)
|
|
if tile && !tile.jumpable:
|
|
vertical_first_clear = false
|
|
|
|
# Choose the valid path for animation
|
|
var use_horizontal_first = true
|
|
if !horizontal_first_clear && vertical_first_clear:
|
|
use_horizontal_first = false
|
|
elif horizontal_first_clear && vertical_first_clear:
|
|
# If both paths are valid, use the traditional logic
|
|
use_horizontal_first = abs(cell_delta_x) > abs(cell_delta_y)
|
|
elif !horizontal_first_clear && !vertical_first_clear:
|
|
push_error("Attempting to animate an invalid move!")
|
|
return
|
|
|
|
if use_horizontal_first:
|
|
mid_pos = Vector2(
|
|
start_pos.x + (cell_delta_x * game.boardXSize),
|
|
start_pos.y
|
|
)
|
|
else:
|
|
mid_pos = Vector2(
|
|
start_pos.x,
|
|
start_pos.y + (cell_delta_y * game.boardYSize)
|
|
)
|
|
|
|
tween.tween_property(self, "global_position", mid_pos, duration / 3 * 2)
|
|
tween.tween_property(self, "global_position", target_position, duration / 3 * 1)
|
|
|
|
await tween.finished
|
|
z_index = 0
|