refactor: rework keyboard input system

entities/game/card_collider/scripts/CardCollider.gd

@@ -9,6 +9,7 @@ var _grid_coordinate: Vector2i = Vector2i.ZERO
 var _shape: CollisionShape2D = null
 
 var _mouse_inside: bool = false
+var _active_state: bool = false
 
 func _ready() -> void:
 	_shape = get_node("%CollisionShape")
@@ -31,6 +32,15 @@ func enable_collider() -> void:
 func disable_collider() -> void:
 	_shape.disabled = true
 
+func is_clicked() -> void:
+	_active_state = false
+
+func reset() -> void:
+	_active_state = true
+
+func is_active() -> bool:
+	return _active_state
+
 func mouse_entered() -> void:
 	mouse_enter.emit(_grid_coordinate)
 	_mouse_inside = true
@@ -40,9 +50,10 @@ func mouse_has_left() -> void:
 	_mouse_inside = false
 
 func input_event(_viewport: Node, event: InputEvent, _shape_idx: int) -> void:
-	if not _mouse_inside:
+	if not _mouse_inside or not _active_state:
 		return
 	if event is InputEventMouseButton:
 		if event.pressed and event.button_index == MouseButton.MOUSE_BUTTON_LEFT:
 			clicked.emit(_grid_coordinate)
 			disable_collider()
+			is_clicked()

entities/game/memory_game/scenes/MemoryGame.tscn

@@ -101,7 +101,7 @@ metadata/_custom_type_script = "uid://bxjrl2ikqn4tk"
 
 [node name="AiAgentSystem" type="Node" parent="Systems" unique_id=1896166842 node_paths=PackedStringArray("cards_node", "players")]
 script = ExtResource("15_u3ner")
-cards_node = NodePath("../../World/CardBoard")
+cards_node = NodePath("../../World/CardBoard/CardInteractionField")
 players = NodePath("../PlayerSystem")
 min_wait_seconds = 0.75
 metadata/_custom_type_script = "uid://c3hyh8ifpeuxg"
@@ -268,8 +268,8 @@ debug_functions = Array[ExtResource("34_4hsit")]([SubResource("Resource_8rpam")]
 [connection signal="player_resource_changed" from="Systems/PlayerSystem" to="World/CardBoard/CardInteractionField" method="player_changed"]
 [connection signal="player_resource_changed" from="Systems/PlayerSystem" to="World/Camera2D" method="player_changed"]
 [connection signal="player_score_changed" from="Systems/PlayerSystem" to="UI/PlayersOverlay" method="player_scored"]
-[connection signal="card_movement" from="Systems/PlayerInputSystem" to="World/CardBoard" method="parse_movement"]
-[connection signal="confirm_current_card" from="Systems/PlayerInputSystem" to="World/CardBoard" method="confirm_current_card"]
+[connection signal="card_movement" from="Systems/PlayerInputSystem" to="World/CardBoard/CardInteractionField" method="parse_movement"]
+[connection signal="confirm_current_card" from="Systems/PlayerInputSystem" to="World/CardBoard/CardInteractionField" method="confirm_selected_card"]
 [connection signal="end_current_round" from="Systems/PlayerInputSystem" to="." method="end_round_now"]
 [connection signal="end_current_round" from="Systems/PlayerInputSystem" to="Systems/GameStateSystem" method="force_end_round"]
 [connection signal="game_menu_requested" from="Systems/PlayerInputSystem" to="." method="show_game_menu"]

entities/game/memory_game/scripts/CardInteractionField.gd

@@ -4,15 +4,31 @@ signal mouse_enter(grid: Vector2i)
 signal mouse_left(grid: Vector2i)
 signal clicked(grid: Vector2i)
 
+enum Axis {X, Y}
+
 @export var default_texture_size: Vector2 = Vector2(499, 550)
 @export var collider_template: PackedScene = null
 @export var additional_offset: Vector2i = Vector2i(0, 25)
 
 var _separation: int = 0
 var _offset: Vector2i = Vector2i.ZERO
 var _card_size: Vector2
+var _field_size: Vector2i = Vector2i.ZERO
 
 var _is_ai_player: bool = false
+var _selected_grid_position: Vector2i = -Vector2i.ONE
+var _controller_input_was_made: bool = false
+
+var possible_movements: Array[Vector2] = [
+		Vector2.RIGHT,
+		Vector2.DOWN,
+		Vector2.LEFT,
+		Vector2.UP
+	]
+
+
+func _reset_grid_position() -> void:
+	_selected_grid_position = -Vector2i.ONE
 
 func set_board_information(deck_to_use: MemoryDeckResource, card_separation: int, field_offset: Vector2i) -> void:
 	var back_image: Texture2D = deck_to_use.get_back_image()
@@ -23,6 +39,7 @@ func set_board_information(deck_to_use: MemoryDeckResource, card_separation: int
 	_offset = field_offset
 
 func build_field(cards_on_x: int, cards_on_y: int) -> void:
+	_field_size = Vector2i(cards_on_x, cards_on_y)
 	for x: int in cards_on_x:
 		for y: int in cards_on_y:
 			var x_addition: int = _separation * x
@@ -63,10 +80,151 @@ func _change_interaction_state(new_state: bool) -> void:
 	for child: CardCollider in get_children():
 		if new_state:
 			child.enable_collider()
+			child.reset()
 		else:
 			child.disable_collider()
 
+
+
+func parse_movement(information: Vector2) -> void:
+	if get_tree().paused or _is_ai_player:
+		_controller_input_was_made = false
+		return
+	_controller_input_was_made = true
+	if information != Vector2.ZERO:
+		Input.set_mouse_mode(Input.MOUSE_MODE_HIDDEN)
+
+	mouse_left.emit(_selected_grid_position)
+	var card_position: Vector2i =_get_closest_card_position(information)
+	if card_position == -Vector2i.ONE:  # or !select_card_at_position(card_position):
+		card_position = _selected_grid_position
+
+	_selected_grid_position = card_position
+	mouse_enter.emit(_selected_grid_position)
+
+func _get_closest_card_position(movement: Vector2) -> Vector2i:
+	var target_position: Vector2i = Vector2i(int(movement.x), int(movement.y)) + _selected_grid_position
+	if _selected_grid_position == -Vector2i.ONE:
+		_selected_grid_position = -Vector2i.ONE
+		target_position = Vector2i.ZERO
+
+	target_position.x = clampi(target_position.x, 0, _field_size.x)
+	target_position.y = clampi(target_position.y, 0, _field_size.y)
+
+	if _selected_grid_position == target_position:
+		return _selected_grid_position
+
+	var axis: Axis = Axis.X
+	var is_negative: bool = false
+	var closest_distance: float = 100000.0
+	var return_position: Vector2i = -Vector2i.ONE
+
+	if movement.y != 0:
+		axis = Axis.Y
+
+	if movement.y < -0.0001 or movement.x < -0.0001:
+		is_negative = true
+	for valid_position: Vector2i in _get_all_relevant_available_cards(_selected_grid_position, is_negative, axis):
+		if valid_position == target_position:
+			return valid_position
+		var calculate_distance: Vector2i = valid_position
+		var weight: int = (_field_size.x + _field_size.y) * 2
+		if axis == Axis.X:
+			if valid_position.x == target_position.x:
+				weight = 0
+		else:
+			if valid_position.y == target_position.y:
+				weight = 0
+		var current_distance: float = calculate_distance.distance_to(target_position) + weight
+		if current_distance < closest_distance:
+			closest_distance = current_distance
+			return_position = valid_position
+
+	return return_position
+
+func get_all_card_positions(get_turned: bool = false) -> Array[Vector2i]:
+	var card_positions: Array[Vector2i] = []
+	for card_collider: CardCollider in get_children():
+		if card_collider != null and not card_collider.is_queued_for_deletion():
+			if get_turned or card_collider.is_active():
+				card_positions.append(card_collider.get_grid_coordinate())
+	return card_positions
+
+func get_all_disabled_cards() -> Array[Vector2i]:
+	var card_positions: Array[Vector2i] = []
+	for card_collider: CardCollider in get_children():
+		if card_collider != null and not card_collider.is_queued_for_deletion():
+			if not card_collider.is_active():
+				card_positions.append(card_collider.get_grid_coordinate())
+	return card_positions
+
+func is_there_a_card_on_position(grid_position: Vector2i) -> bool:
+	for card_collider: CardCollider in get_children():
+		if card_collider.get_grid_coordinate() == grid_position:
+			var active: bool = card_collider.is_active()
+			return active
+	return false
+
+func _get_all_relevant_available_cards(current_pos: Vector2i, go_negative: bool, axis: Axis) -> Array[Vector2i]:
+	var valid_cards: Array[Vector2i] = []
+	for card_collider: Node in get_children():
+		if card_collider != null and not card_collider.is_queued_for_deletion() and card_collider is CardCollider:
+			if _check_if_valid_card(current_pos, go_negative, axis, card_collider):
+				valid_cards.append(card_collider.get_grid_coordinate())
+	return valid_cards
+
+func _check_if_valid_card(current_pos: Vector2i, go_negative: bool, axis: Axis, card: CardCollider) -> bool:
+	if not card.is_active():
+		return false
+	match axis:
+		Axis.X:
+			if go_negative:
+				return card.get_grid_coordinate().x < current_pos.x
+			return card.get_grid_coordinate().x > current_pos.x
+		Axis.Y:
+			if go_negative:
+				return card.get_grid_coordinate().y < current_pos.y
+			return card.get_grid_coordinate().y > current_pos.y
+
+	return false
+
+func confirm_selected_card() -> void:
+	mouse_has_clicked(_selected_grid_position)
+
 func _connect_card_interaction(collider: CardCollider) -> void:
-	collider.mouse_enter.connect(func(data: Vector2i) -> void: mouse_enter.emit(data))
-	collider.mouse_left.connect(func(data: Vector2i) -> void: mouse_left.emit(data))
-	collider.clicked.connect(func(data: Vector2i) -> void: clicked.emit(data))
+	collider.mouse_enter.connect(mouse_has_entered)
+	collider.mouse_enter.connect(_mouse_movement_was_made)
+	collider.mouse_left.connect(mouse_has_left)
+	collider.mouse_left.connect(_mouse_movement_was_made)
+	collider.clicked.connect(mouse_has_clicked)
+
+func _mouse_movement_was_made(_grid_position: Vector2i) -> void:
+	_controller_input_was_made = false
+	Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+
+func mouse_has_clicked(grid_position: Vector2i) -> void:
+	clicked.emit(grid_position)
+	for collider: CardCollider in get_children():
+		if collider.get_grid_coordinate() == grid_position:
+			collider.is_clicked()
+	if not _controller_input_was_made:
+		_reset_grid_position()
+		return
+	_selected_grid_position = _get_closest_card()
+	mouse_has_entered(_selected_grid_position)
+
+func _get_closest_card() -> Vector2i:
+	for direction: Vector2 in possible_movements:
+		var possible_position: Vector2i = _get_closest_card_position(direction)
+		if possible_position != -Vector2i.ONE:
+			return possible_position
+
+	return -Vector2i.ONE
+
+func mouse_has_entered(grid_position: Vector2i) -> void:
+	mouse_enter.emit(grid_position)
+	_selected_grid_position = grid_position
+
+func mouse_has_left(grid_position: Vector2i) -> void:
+	mouse_left.emit(grid_position)
+	_selected_grid_position = grid_position

entities/game/memory_game/scripts/GameCardGrid.gd

@@ -101,82 +101,16 @@ func select_card_at_position(grid_position: Vector2i) -> bool:
 		current_card.got_focus()
 	return found_card
 
-func confirm_current_card() -> void:
-	if current_card == null or get_tree().paused:
-		return
-	current_card.card_was_clicked()
 
 func get_card_on_position(card_position: Vector2i) -> MemoryCardResource:
 	for card: CardTemplate in _get_game_card_templates_children():
 		if card_position == card.grid_position:
 			return card.memory_card
 	return null
-
-func parse_movement(information: Vector2) -> void:
-	if get_tree().paused or currently_ai_player:
-		return
-	controller_input_was_made = true
-	if information != Vector2.ZERO:
-		Input.set_mouse_mode(Input.MOUSE_MODE_HIDDEN)
-
-	var card_position: Vector2i =_get_closest_card_position(information)
-	if card_position == -Vector2i.ONE or !select_card_at_position(card_position):
-		current_card = null
-
-func _get_closest_card_position(movement: Vector2) -> Vector2i:
-	var current_selected_card: Vector2i = get_current_grid_position()
-	var target_position: Vector2i = Vector2i(int(movement.x), int(movement.y)) + current_selected_card
-	if current_selected_card == -Vector2i.ONE:
-		current_selected_card = -Vector2i.ONE
-		target_position = Vector2i.ZERO
-
-	target_position.x = clampi(target_position.x, 0, _field_size.x)
-	target_position.y = clampi(target_position.y, 0, _field_size.y)
-
-	if current_selected_card == target_position:
-		return current_selected_card
-
-	print(target_position)
-
-	var axis: Axis = Axis.X
-	var is_negative: bool = false
-	var closest_distance: float = 100000.0
-	var return_position: Vector2i = -Vector2i.ONE
-
-	if movement.y != 0:
-		axis = Axis.Y
-
-	if movement.y < -0.0001 or movement.x < -0.0001:
-		is_negative = true
-	for valid_position: Vector2i in _get_valid_card_positions(current_selected_card, is_negative, axis):
-		if valid_position == target_position:
-			return valid_position
-		var calculate_distance: Vector2i = valid_position
-		var weight: int = (_field_size.x + _field_size.y) * 2
-		if axis == Axis.X:
-			if valid_position.x == target_position.x:
-				weight = 0
-		else:
-			if valid_position.y == target_position.y:
-				weight = 0
-		var current_distance: float = calculate_distance.distance_to(target_position) + weight
-		if current_distance < closest_distance:
-			closest_distance = current_distance
-			return_position = valid_position
-
-	return return_position
 
 func round_frozen() -> void:
 	current_card = null
 
-func round_unfrozen() -> void:
-	if currently_ai_player:
-		controller_input_was_made = false
-		return
-	if controller_input_was_made:
-		_get_closest_card_position(Vector2i(1,0))
-	controller_input_was_made = false
-
 func card_loading_done() -> void:
 	for card: CardTemplate in _get_game_card_templates():
 		card.mouse_was_used.connect(func() -> void: 
@@ -187,7 +121,6 @@ func card_loading_done() -> void:
 func game_state_changed(game_state: GameEnum.State) -> void:
 	match game_state:
 		GameEnum.State.TURN_START:
-			round_unfrozen()
 			for card: CardTemplate in _get_game_card_templates():
 				card.player_changed(currently_ai_player)
 			print(_get_game_card_templates().size())
@@ -212,7 +145,6 @@ func _validate_grid() -> void:
 		if card == null or card.is_queued_for_deletion():
 			continue
 		if card.is_turned() and not card.card_is_fully_shown():
-			print("Waiting")
 			await card.fully_shown
 	if _any_matching():
 		var card_positions: Array[Vector2i] = []
@@ -303,7 +235,6 @@ func card_was_placed(card: CardTemplate) -> void:
 	card.card_triggered.connect(card_triggered_hook)
 	state_machine.state_changed.connect(card.game_state_changed)
 
-
 func card_triggered_hook(card: CardTemplate) -> void:
 	select_card_at_position(card.grid_position)
 	card_triggered.emit(card)

entities/game/memory_game/scripts/systems/AiAgentSystem.gd

@@ -1,6 +1,6 @@
 class_name AiAgentSystem extends Node
 
-@export var cards_node: GameCardGrid
+@export var cards_node: CardInteractionField
 @export var players: PlayerSystem
 @export var min_wait_seconds: float = 0.5
 @export var max_wait_seconds: float = 3

shared/entities/ai_behavior/resources/AiBehaviorNode.gd

@@ -5,19 +5,16 @@ class_name AiBehaviorNode extends Resource
 func get_execution_probability() -> int:
 	return probability
 
-func can_execute(_blackboard: Blackboard, _grid: GameCardGrid) -> bool:
+func can_execute(_blackboard: Blackboard, _grid: CardInteractionField) -> bool:
 	return false
 
-func execute_action(_blackboard: Blackboard, _grid: GameCardGrid) -> void:
+func execute_action(_blackboard: Blackboard, _grid: CardInteractionField) -> void:
 	pass
 
-func _trigger_card(position: Vector2i, _blackboard: Blackboard, grid: GameCardGrid) -> bool:
-	var card: MemoryCardResource = grid.get_card_on_position(position)
-	if card == null:
+func _trigger_card(position: Vector2i, _blackboard: Blackboard, grid: CardInteractionField) -> bool:
+	var card_existing: bool = grid.is_there_a_card_on_position(position)
+	if not card_existing:
 		return false
 
-	if grid.select_card_at_position(position):
-		grid.confirm_current_card()
-		return true
-
-	return false
+	grid.mouse_has_clicked(position)
+	return not grid.is_there_a_card_on_position(position)