nett00n/skelly
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add gdlint and gdformat scripts

Browse Source
This commit is contained in:
Vladimir nett00n Budylnikov
2025-09-27 20:40:13 +04:00
parent 86439abea8
commit 06f0f87970
40 changed files with 2314 additions and 732 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
scenes/game/game.gd
View File

@@ -10,14 +10,19 @@ const GAMEPLAY_SCENES = {
@onready var score_display: Label = $UI/ScoreDisplay
var current_gameplay_mode: String
var global_score: int = 0 : set = set_global_score
var global_score: int = 0:
set = set_global_score
func _ready() -> void:
if not back_button.pressed.is_connected(_on_back_button_pressed):
back_button.pressed.connect(_on_back_button_pressed)
# GameManager will set the gameplay mode, don't set default here
DebugManager.log_debug("Game _ready() completed, waiting for GameManager to set gameplay mode", "Game")
DebugManager.log_debug(
"Game _ready() completed, waiting for GameManager to set gameplay mode", "Game"
)
func set_gameplay_mode(mode: String) -> void:
DebugManager.log_info("set_gameplay_mode called with mode: %s" % mode, "Game")
@@ -25,6 +30,7 @@ func set_gameplay_mode(mode: String) -> void:
await load_gameplay(mode)
DebugManager.log_info("set_gameplay_mode completed for mode: %s" % mode, "Game")
func load_gameplay(mode: String) -> void:
DebugManager.log_debug("Loading gameplay mode: %s" % mode, "Game")
@@ -38,7 +44,10 @@ func load_gameplay(mode: String) -> void:
# Wait for children to be properly removed from scene tree
await get_tree().process_frame
DebugManager.log_debug("Children removal complete, container count: %d" % gameplay_container.get_child_count(), "Game")
DebugManager.log_debug(
"Children removal complete, container count: %d" % gameplay_container.get_child_count(),
"Game"
)
# Load new gameplay
if GAMEPLAY_SCENES.has(mode):
@@ -47,7 +56,13 @@ func load_gameplay(mode: String) -> void:
var gameplay_instance = gameplay_scene.instantiate()
DebugManager.log_debug("Instantiated gameplay: %s" % gameplay_instance.name, "Game")
gameplay_container.add_child(gameplay_instance)
DebugManager.log_debug("Added gameplay to container, child count now: %d" % gameplay_container.get_child_count(), "Game")
DebugManager.log_debug(
(
"Added gameplay to container, child count now: %d"
% gameplay_container.get_child_count()
),
"Game"
)
# Connect gameplay signals to shared systems
if gameplay_instance.has_signal("score_changed"):
@@ -56,23 +71,28 @@ func load_gameplay(mode: String) -> void:
else:
DebugManager.log_error("Gameplay mode '%s' not found in GAMEPLAY_SCENES" % mode, "Game")
func set_global_score(value: int) -> void:
global_score = value
if score_display:
score_display.text = "Score: " + str(global_score)
func _on_score_changed(points: int) -> void:
self.global_score += points
SaveManager.update_current_score(self.global_score)
func get_global_score() -> int:
return global_score
func _get_current_gameplay_instance() -> Node:
if gameplay_container.get_child_count() > 0:
return gameplay_container.get_child(0)
return null
func _on_back_button_pressed() -> void:
DebugManager.log_debug("Back button pressed in game scene", "Game")
AudioManager.play_ui_click()
@@ -91,6 +111,7 @@ func _on_back_button_pressed() -> void:
SaveManager.finish_game(global_score)
GameManager.exit_to_main_menu()
func _input(event: InputEvent) -> void:
if event.is_action_pressed("ui_back"):
# Handle gamepad/keyboard back action - same as back button

12
scenes/game/gameplays/Match3DebugMenu.gd
View File

@@ -1,5 +1,6 @@
extends DebugMenuBase
func _ready():
# Set specific configuration for Match3DebugMenu
log_category = "Match3"
@@ -15,6 +16,7 @@ func _ready():
if current_debug_state:
_on_debug_toggled(true)
func _find_target_scene():
# Debug menu is now: Match3 -> UILayer -> Match3DebugMenu
# So we need to go up two levels: get_parent() = UILayer, get_parent().get_parent() = Match3
@@ -25,7 +27,15 @@ func _find_target_scene():
var script_path = potential_match3.get_script().resource_path
if script_path == target_script_path:
match3_scene = potential_match3
DebugManager.log_debug("Found match3 scene: " + match3_scene.name + " at path: " + str(match3_scene.get_path()), log_category)
DebugManager.log_debug(
(
"Found match3 scene: "
+ match3_scene.name
+ " at path: "
+ str(match3_scene.get_path())
),
log_category
)
_update_ui_from_scene()
_stop_search_timer()
return

1
scenes/game/gameplays/clickomania_gameplay.gd
View File

@@ -2,6 +2,7 @@ extends Node2D
signal score_changed(points: int)
func _ready():
DebugManager.log_info("Clickomania gameplay loaded", "Clickomania")
# Example: Add some score after a few seconds to test the system

368
scenes/game/gameplays/match3_gameplay.gd
View File

@@ -3,12 +3,7 @@ extends Node2D
signal score_changed(points: int)
signal grid_state_loaded(grid_size: Vector2i, tile_types: int)
enum GameState {
WAITING, # Waiting for player input
SELECTING, # First tile selected
SWAPPING, # Animating tile swap
PROCESSING # Processing matches and cascades
}
enum GameState { WAITING, SELECTING, SWAPPING, PROCESSING } # Waiting for player input # First tile selected # Animating tile swap # Processing matches and cascades
var GRID_SIZE := Vector2i(8, 8)
var TILE_TYPES := 5
@@ -32,22 +27,26 @@ const CASCADE_WAIT_TIME := 0.1
const SWAP_ANIMATION_TIME := 0.3
const TILE_DROP_WAIT_TIME := 0.2
var grid := []
var grid: Array[Array] = []
var tile_size: float = 48.0
var grid_offset: Vector2
var grid_offset: Vector2 = Vector2.ZERO
var current_state: GameState = GameState.WAITING
var selected_tile: Node2D = null
var cursor_position: Vector2i = Vector2i(0, 0)
var keyboard_navigation_enabled: bool = false
var grid_initialized: bool = false
var instance_id: String
var instance_id: String = ""
func _ready():
func _ready() -> void:
# Generate instance ID
instance_id = "Match3_%d" % get_instance_id()
if grid_initialized:
DebugManager.log_warn("[%s] Match3 _ready() called multiple times, skipping initialization" % instance_id, "Match3")
DebugManager.log_warn(
"[%s] Match3 _ready() called multiple times, skipping initialization" % instance_id,
"Match3"
)
return
DebugManager.log_debug("[%s] Match3 _ready() started" % instance_id, "Match3")
@@ -72,6 +71,7 @@ func _ready():
# Debug: Check scene tree structure
call_deferred("_debug_scene_structure")
func _calculate_grid_layout():
var viewport_size = get_viewport().get_visible_rect().size
var available_width = viewport_size.x * SCREEN_WIDTH_USAGE
@@ -85,13 +85,13 @@ func _calculate_grid_layout():
# Align grid to left side with margins
var total_grid_height = tile_size * GRID_SIZE.y
grid_offset = Vector2(
GRID_LEFT_MARGIN,
(viewport_size.y - total_grid_height) / 2 + GRID_TOP_MARGIN
GRID_LEFT_MARGIN, (viewport_size.y - total_grid_height) / 2 + GRID_TOP_MARGIN
)
func _initialize_grid():
# Create gem pool for current tile types
var gem_indices = []
var gem_indices: Array[int] = []
for i in range(TILE_TYPES):
gem_indices.append(i)
@@ -113,9 +113,16 @@ func _initialize_grid():
# Connect tile signals
tile.tile_selected.connect(_on_tile_selected)
DebugManager.log_debug("Created tile at grid(%d,%d) world_pos(%s) with type %d" % [x, y, tile_position, new_type], "Match3")
DebugManager.log_debug(
(
"Created tile at grid(%d,%d) world_pos(%s) with type %d"
% [x, y, tile_position, new_type]
),
"Match3"
)
grid[y].append(tile)
func _has_match_at(pos: Vector2i) -> bool:
# Bounds and null checks
if not _is_valid_grid_position(pos):
@@ -131,7 +138,9 @@ func _has_match_at(pos: Vector2i) -> bool:
# Check if tile has required properties
if not "tile_type" in tile:
DebugManager.log_warn("Tile at (%d,%d) missing tile_type property" % [pos.x, pos.y], "Match3")
DebugManager.log_warn(
"Tile at (%d,%d) missing tile_type property" % [pos.x, pos.y], "Match3"
)
return false
var matches_horizontal = _get_match_line(pos, Vector2i(1, 0))
@@ -141,6 +150,7 @@ func _has_match_at(pos: Vector2i) -> bool:
var matches_vertical = _get_match_line(pos, Vector2i(0, 1))
return matches_vertical.size() >= 3
# Check for any matches on the board
func _check_for_matches() -> bool:
for y in range(GRID_SIZE.y):
@@ -149,14 +159,19 @@ func _check_for_matches() -> bool:
return true
return false
func _get_match_line(start: Vector2i, dir: Vector2i) -> Array:
# Validate input parameters
if not _is_valid_grid_position(start):
DebugManager.log_error("Invalid start position for match line: (%d,%d)" % [start.x, start.y], "Match3")
DebugManager.log_error(
"Invalid start position for match line: (%d,%d)" % [start.x, start.y], "Match3"
)
return []
if abs(dir.x) + abs(dir.y) != 1 or (dir.x != 0 and dir.y != 0):
DebugManager.log_error("Invalid direction vector for match line: (%d,%d)" % [dir.x, dir.y], "Match3")
DebugManager.log_error(
"Invalid direction vector for match line: (%d,%d)" % [dir.x, dir.y], "Match3"
)
return []
# Check grid bounds and tile validity
@@ -194,6 +209,7 @@ func _get_match_line(start: Vector2i, dir: Vector2i) -> Array:
return line
func _clear_matches():
# Check grid integrity
if not _validate_grid_integrity():
@@ -278,10 +294,17 @@ func _clear_matches():
var tile_pos = tile.grid_position
# Validate grid position before clearing reference
if _is_valid_grid_position(tile_pos) and tile_pos.y < grid.size() and tile_pos.x < grid[tile_pos.y].size():
if (
_is_valid_grid_position(tile_pos)
and tile_pos.y < grid.size()
and tile_pos.x < grid[tile_pos.y].size()
):
grid[tile_pos.y][tile_pos.x] = null
else:
DebugManager.log_warn("Invalid grid position during tile removal: (%d,%d)" % [tile_pos.x, tile_pos.y], "Match3")
DebugManager.log_warn(
"Invalid grid position during tile removal: (%d,%d)" % [tile_pos.x, tile_pos.y],
"Match3"
)
tile.queue_free()
@@ -291,6 +314,7 @@ func _clear_matches():
await get_tree().create_timer(TILE_DROP_WAIT_TIME).timeout
_fill_empty_cells()
func _drop_tiles():
var moved = true
while moved:
@@ -309,6 +333,7 @@ func _drop_tiles():
tile.position = grid_offset + Vector2(x, y + 1) * tile_size
moved = true
func _fill_empty_cells():
# Safety check for grid integrity
if not _validate_grid_integrity():
@@ -316,7 +341,7 @@ func _fill_empty_cells():
return
# Create gem pool for current tile types
var gem_indices = []
var gem_indices: Array[int] = []
for i in range(TILE_TYPES):
gem_indices.append(i)
@@ -334,7 +359,9 @@ func _fill_empty_cells():
if not grid[y][x]:
var tile = TILE_SCENE.instantiate()
if not tile:
DebugManager.log_error("Failed to instantiate tile at (%d,%d)" % [x, y], "Match3")
DebugManager.log_error(
"Failed to instantiate tile at (%d,%d)" % [x, y], "Match3"
)
continue
tile.grid_position = Vector2i(x, y)
@@ -375,19 +402,35 @@ func _fill_empty_cells():
iteration += 1
if iteration >= MAX_CASCADE_ITERATIONS:
DebugManager.log_warn("Maximum cascade iterations reached (%d), stopping to prevent infinite loop" % MAX_CASCADE_ITERATIONS, "Match3")
DebugManager.log_warn(
(
"Maximum cascade iterations reached (%d), stopping to prevent infinite loop"
% MAX_CASCADE_ITERATIONS
),
"Match3"
)
# Save grid state after cascades complete
save_current_state()
func regenerate_grid():
# Validate grid size before regeneration
if GRID_SIZE.x < MIN_GRID_SIZE or GRID_SIZE.y < MIN_GRID_SIZE or GRID_SIZE.x > MAX_GRID_SIZE or GRID_SIZE.y > MAX_GRID_SIZE:
DebugManager.log_error("Invalid grid size for regeneration: %dx%d" % [GRID_SIZE.x, GRID_SIZE.y], "Match3")
if (
GRID_SIZE.x < MIN_GRID_SIZE
or GRID_SIZE.y < MIN_GRID_SIZE
or GRID_SIZE.x > MAX_GRID_SIZE
or GRID_SIZE.y > MAX_GRID_SIZE
):
DebugManager.log_error(
"Invalid grid size for regeneration: %dx%d" % [GRID_SIZE.x, GRID_SIZE.y], "Match3"
)
return
if TILE_TYPES < 3 or TILE_TYPES > MAX_TILE_TYPES:
DebugManager.log_error("Invalid tile types count for regeneration: %d" % TILE_TYPES, "Match3")
DebugManager.log_error(
"Invalid tile types count for regeneration: %d" % TILE_TYPES, "Match3"
)
return
# Use time-based seed to ensure different patterns each time
@@ -440,6 +483,7 @@ func regenerate_grid():
# Regenerate the grid with safety checks
_initialize_grid()
func set_tile_types(new_count: int):
# Input validation
if new_count < 3:
@@ -447,7 +491,9 @@ func set_tile_types(new_count: int):
return
if new_count > MAX_TILE_TYPES:
DebugManager.log_error("Tile types count too high: %d (maximum %d)" % [new_count, MAX_TILE_TYPES], "Match3")
DebugManager.log_error(
"Tile types count too high: %d (maximum %d)" % [new_count, MAX_TILE_TYPES], "Match3"
)
return
if new_count == TILE_TYPES:
@@ -460,14 +506,27 @@ func set_tile_types(new_count: int):
# Regenerate grid with new tile types (gem pool is updated in regenerate_grid)
await regenerate_grid()
func set_grid_size(new_size: Vector2i):
# Comprehensive input validation
if new_size.x < MIN_GRID_SIZE or new_size.y < MIN_GRID_SIZE:
DebugManager.log_error("Grid size too small: %dx%d (minimum %dx%d)" % [new_size.x, new_size.y, MIN_GRID_SIZE, MIN_GRID_SIZE], "Match3")
DebugManager.log_error(
(
"Grid size too small: %dx%d (minimum %dx%d)"
% [new_size.x, new_size.y, MIN_GRID_SIZE, MIN_GRID_SIZE]
),
"Match3"
)
return
if new_size.x > MAX_GRID_SIZE or new_size.y > MAX_GRID_SIZE:
DebugManager.log_error("Grid size too large: %dx%d (maximum %dx%d)" % [new_size.x, new_size.y, MAX_GRID_SIZE, MAX_GRID_SIZE], "Match3")
DebugManager.log_error(
(
"Grid size too large: %dx%d (maximum %dx%d)"
% [new_size.x, new_size.y, MAX_GRID_SIZE, MAX_GRID_SIZE]
),
"Match3"
)
return
if new_size == GRID_SIZE:
@@ -480,6 +539,7 @@ func set_grid_size(new_size: Vector2i):
# Regenerate grid with new size
await regenerate_grid()
func reset_all_visual_states() -> void:
# Debug function to reset all tile visual states
DebugManager.log_debug("Resetting all tile visual states", "Match3")
@@ -493,6 +553,7 @@ func reset_all_visual_states() -> void:
current_state = GameState.WAITING
keyboard_navigation_enabled = false
func _debug_scene_structure() -> void:
DebugManager.log_debug("=== Scene Structure Debug ===", "Match3")
DebugManager.log_debug("Match3 node children count: %d" % get_child_count(), "Match3")
@@ -510,22 +571,30 @@ func _debug_scene_structure() -> void:
for x in range(GRID_SIZE.x):
if y < grid.size() and x < grid[y].size() and grid[y][x]:
tile_count += 1
DebugManager.log_debug("Created %d tiles out of %d expected" % [tile_count, GRID_SIZE.x * GRID_SIZE.y], "Match3")
DebugManager.log_debug(
"Created %d tiles out of %d expected" % [tile_count, GRID_SIZE.x * GRID_SIZE.y], "Match3"
)
# Check first tile in detail
if grid.size() > 0 and grid[0].size() > 0 and grid[0][0]:
var first_tile = grid[0][0]
DebugManager.log_debug("First tile global position: %s" % first_tile.global_position, "Match3")
DebugManager.log_debug(
"First tile global position: %s" % first_tile.global_position, "Match3"
)
DebugManager.log_debug("First tile local position: %s" % first_tile.position, "Match3")
# Check parent chain
var current_node = self
var depth = 0
while current_node and depth < 10:
DebugManager.log_debug("Parent level %d: %s (type: %s)" % [depth, current_node.name, current_node.get_class()], "Match3")
DebugManager.log_debug(
"Parent level %d: %s (type: %s)" % [depth, current_node.name, current_node.get_class()],
"Match3"
)
current_node = current_node.get_parent()
depth += 1
func _input(event: InputEvent) -> void:
# Debug key to reset all visual states
if event.is_action_pressed("action_east") and DebugManager.is_debug_enabled():
@@ -560,7 +629,9 @@ func _move_cursor(direction: Vector2i) -> void:
return
if direction.x != 0 and direction.y != 0:
DebugManager.log_error("Diagonal cursor movement not supported: " + str(direction), "Match3")
DebugManager.log_error(
"Diagonal cursor movement not supported: " + str(direction), "Match3"
)
return
# Validate grid integrity before cursor operations
@@ -582,7 +653,10 @@ func _move_cursor(direction: Vector2i) -> void:
if not old_tile.is_selected:
old_tile.is_highlighted = false
DebugManager.log_debug("Cursor moved from (%d,%d) to (%d,%d)" % [old_pos.x, old_pos.y, new_pos.x, new_pos.y], "Match3")
DebugManager.log_debug(
"Cursor moved from (%d,%d) to (%d,%d)" % [old_pos.x, old_pos.y, new_pos.x, new_pos.y],
"Match3"
)
cursor_position = new_pos
# Safe access to new tile
@@ -591,25 +665,48 @@ func _move_cursor(direction: Vector2i) -> void:
if not new_tile.is_selected:
new_tile.is_highlighted = true
func _select_tile_at_cursor() -> void:
# Validate cursor position and grid integrity
if not _is_valid_grid_position(cursor_position):
DebugManager.log_warn("Invalid cursor position for selection: (%d,%d)" % [cursor_position.x, cursor_position.y], "Match3")
DebugManager.log_warn(
(
"Invalid cursor position for selection: (%d,%d)"
% [cursor_position.x, cursor_position.y]
),
"Match3"
)
return
var tile = _safe_grid_access(cursor_position)
if tile:
DebugManager.log_debug("Keyboard selection at cursor (%d,%d)" % [cursor_position.x, cursor_position.y], "Match3")
DebugManager.log_debug(
"Keyboard selection at cursor (%d,%d)" % [cursor_position.x, cursor_position.y],
"Match3"
)
_on_tile_selected(tile)
else:
DebugManager.log_warn("No valid tile at cursor position (%d,%d)" % [cursor_position.x, cursor_position.y], "Match3")
DebugManager.log_warn(
"No valid tile at cursor position (%d,%d)" % [cursor_position.x, cursor_position.y],
"Match3"
)
func _on_tile_selected(tile: Node2D) -> void:
if current_state == GameState.SWAPPING or current_state == GameState.PROCESSING:
DebugManager.log_debug("Tile selection ignored - game busy (state: %s)" % [GameState.keys()[current_state]], "Match3")
DebugManager.log_debug(
"Tile selection ignored - game busy (state: %s)" % [GameState.keys()[current_state]],
"Match3"
)
return
DebugManager.log_debug("Tile selected at (%d,%d), gem type: %d" % [tile.grid_position.x, tile.grid_position.y, tile.tile_type], "Match3")
DebugManager.log_debug(
(
"Tile selected at (%d,%d), gem type: %d"
% [tile.grid_position.x, tile.grid_position.y, tile.tile_type]
),
"Match3"
)
if current_state == GameState.WAITING:
# First tile selection
@@ -621,7 +718,18 @@ func _on_tile_selected(tile: Node2D) -> void:
_deselect_tile()
else:
# Attempt to swap with selected tile
DebugManager.log_debug("Attempting swap between (%d,%d) and (%d,%d)" % [selected_tile.grid_position.x, selected_tile.grid_position.y, tile.grid_position.x, tile.grid_position.y], "Match3")
DebugManager.log_debug(
(
"Attempting swap between (%d,%d) and (%d,%d)"
% [
selected_tile.grid_position.x,
selected_tile.grid_position.y,
tile.grid_position.x,
tile.grid_position.y
]
),
"Match3"
)
_attempt_swap(selected_tile, tile)
@@ -629,13 +737,22 @@ func _select_tile(tile: Node2D) -> void:
selected_tile = tile
tile.is_selected = true
current_state = GameState.SELECTING
DebugManager.log_debug("Selected tile at (%d, %d)" % [tile.grid_position.x, tile.grid_position.y], "Match3")
DebugManager.log_debug(
"Selected tile at (%d, %d)" % [tile.grid_position.x, tile.grid_position.y], "Match3"
)
func _deselect_tile() -> void:
if selected_tile and is_instance_valid(selected_tile):
# Safe access to tile properties
if "grid_position" in selected_tile:
DebugManager.log_debug("Deselecting tile at (%d,%d)" % [selected_tile.grid_position.x, selected_tile.grid_position.y], "Match3")
DebugManager.log_debug(
(
"Deselecting tile at (%d,%d)"
% [selected_tile.grid_position.x, selected_tile.grid_position.y]
),
"Match3"
)
else:
DebugManager.log_debug("Deselecting tile (no grid position available)", "Match3")
@@ -653,7 +770,13 @@ func _deselect_tile() -> void:
var cursor_tile = _safe_grid_access(cursor_position)
if cursor_tile and "is_highlighted" in cursor_tile:
cursor_tile.is_highlighted = true
DebugManager.log_debug("Restored cursor highlighting at (%d,%d)" % [cursor_position.x, cursor_position.y], "Match3")
DebugManager.log_debug(
(
"Restored cursor highlighting at (%d,%d)"
% [cursor_position.x, cursor_position.y]
),
"Match3"
)
else:
# For mouse navigation, just clear highlighting
if "is_highlighted" in selected_tile:
@@ -662,6 +785,7 @@ func _deselect_tile() -> void:
selected_tile = null
current_state = GameState.WAITING
func _are_adjacent(tile1: Node2D, tile2: Node2D) -> bool:
if not tile1 or not tile2:
return false
@@ -671,19 +795,44 @@ func _are_adjacent(tile1: Node2D, tile2: Node2D) -> bool:
var diff = abs(pos1.x - pos2.x) + abs(pos1.y - pos2.y)
return diff == 1
func _attempt_swap(tile1: Node2D, tile2: Node2D) -> void:
if not _are_adjacent(tile1, tile2):
DebugManager.log_debug("Tiles are not adjacent, cannot swap", "Match3")
return
DebugManager.log_debug("Starting swap animation: (%d,%d)[type:%d] <-> (%d,%d)[type:%d]" % [tile1.grid_position.x, tile1.grid_position.y, tile1.tile_type, tile2.grid_position.x, tile2.grid_position.y, tile2.tile_type], "Match3")
DebugManager.log_debug(
(
"Starting swap animation: (%d,%d)[type:%d] <-> (%d,%d)[type:%d]"
% [
tile1.grid_position.x,
tile1.grid_position.y,
tile1.tile_type,
tile2.grid_position.x,
tile2.grid_position.y,
tile2.tile_type
]
),
"Match3"
)
current_state = GameState.SWAPPING
await _swap_tiles(tile1, tile2)
# Check if swap creates matches
if _has_match_at(tile1.grid_position) or _has_match_at(tile2.grid_position):
DebugManager.log_info("Valid swap created matches at (%d,%d) or (%d,%d)" % [tile1.grid_position.x, tile1.grid_position.y, tile2.grid_position.x, tile2.grid_position.y], "Match3")
DebugManager.log_info(
(
"Valid swap created matches at (%d,%d) or (%d,%d)"
% [
tile1.grid_position.x,
tile1.grid_position.y,
tile2.grid_position.x,
tile2.grid_position.y
]
),
"Match3"
)
_deselect_tile()
current_state = GameState.PROCESSING
_clear_matches()
@@ -697,6 +846,7 @@ func _attempt_swap(tile1: Node2D, tile2: Node2D) -> void:
_deselect_tile()
current_state = GameState.WAITING
func _swap_tiles(tile1: Node2D, tile2: Node2D) -> void:
if not tile1 or not tile2:
DebugManager.log_error("Cannot swap tiles - one or both tiles are null", "Match3")
@@ -706,7 +856,13 @@ func _swap_tiles(tile1: Node2D, tile2: Node2D) -> void:
var pos1 = tile1.grid_position
var pos2 = tile2.grid_position
DebugManager.log_debug("Swapping tile positions: (%d,%d) -> (%d,%d), (%d,%d) -> (%d,%d)" % [pos1.x, pos1.y, pos2.x, pos2.y, pos2.x, pos2.y, pos1.x, pos1.y], "Match3")
DebugManager.log_debug(
(
"Swapping tile positions: (%d,%d) -> (%d,%d), (%d,%d) -> (%d,%d)"
% [pos1.x, pos1.y, pos2.x, pos2.y, pos2.x, pos2.y, pos1.x, pos1.y]
),
"Match3"
)
tile1.grid_position = pos2
tile2.grid_position = pos1
@@ -729,9 +885,16 @@ func _swap_tiles(tile1: Node2D, tile2: Node2D) -> void:
await tween.finished
DebugManager.log_trace("Tile swap animation completed", "Match3")
func serialize_grid_state() -> Array:
# Convert the current grid to a serializable 2D array
DebugManager.log_info("Starting serialization: grid.size()=%d, GRID_SIZE=(%d,%d)" % [grid.size(), GRID_SIZE.x, GRID_SIZE.y], "Match3")
DebugManager.log_info(
(
"Starting serialization: grid.size()=%d, GRID_SIZE=(%d,%d)"
% [grid.size(), GRID_SIZE.x, GRID_SIZE.y]
),
"Match3"
)
if grid.size() == 0:
DebugManager.log_error("Grid array is empty during serialization!", "Match3")
@@ -749,18 +912,29 @@ func serialize_grid_state() -> Array:
valid_tiles += 1
# Only log first few for brevity
if valid_tiles <= 5:
DebugManager.log_debug("Serializing tile (%d,%d): type %d" % [x, y, grid[y][x].tile_type], "Match3")
DebugManager.log_debug(
"Serializing tile (%d,%d): type %d" % [x, y, grid[y][x].tile_type], "Match3"
)
else:
row.append(-1) # Invalid/empty tile
null_tiles += 1
# Only log first few nulls for brevity
if null_tiles <= 5:
DebugManager.log_debug("Serializing tile (%d,%d): NULL/empty (-1)" % [x, y], "Match3")
DebugManager.log_debug(
"Serializing tile (%d,%d): NULL/empty (-1)" % [x, y], "Match3"
)
serialized_grid.append(row)
DebugManager.log_info("Serialized grid state: %dx%d grid, %d valid tiles, %d null tiles" % [GRID_SIZE.x, GRID_SIZE.y, valid_tiles, null_tiles], "Match3")
DebugManager.log_info(
(
"Serialized grid state: %dx%d grid, %d valid tiles, %d null tiles"
% [GRID_SIZE.x, GRID_SIZE.y, valid_tiles, null_tiles]
),
"Match3"
)
return serialized_grid
func get_active_gem_types() -> Array:
# Get active gem types from the first available tile
if grid.size() > 0 and grid[0].size() > 0 and grid[0][0]:
@@ -772,15 +946,23 @@ func get_active_gem_types() -> Array:
default_types.append(i)
return default_types
func save_current_state():
# Save complete game state
var grid_layout = serialize_grid_state()
var active_gems = get_active_gem_types()
DebugManager.log_info("Saving match3 state: size(%d,%d), %d tile types, %d active gems" % [GRID_SIZE.x, GRID_SIZE.y, TILE_TYPES, active_gems.size()], "Match3")
DebugManager.log_info(
(
"Saving match3 state: size(%d,%d), %d tile types, %d active gems"
% [GRID_SIZE.x, GRID_SIZE.y, TILE_TYPES, active_gems.size()]
),
"Match3"
)
SaveManager.save_grid_state(GRID_SIZE, TILE_TYPES, active_gems, grid_layout)
func load_saved_state() -> bool:
# Check if there's a saved grid state
if not SaveManager.has_saved_grid():
@@ -792,10 +974,18 @@ func load_saved_state() -> bool:
# Restore grid settings
var saved_size = Vector2i(saved_state.grid_size.x, saved_state.grid_size.y)
TILE_TYPES = saved_state.tile_types_count
var saved_gems = saved_state.active_gem_types
var saved_gems: Array[int] = []
for gem in saved_state.active_gem_types:
saved_gems.append(int(gem))
var saved_layout = saved_state.grid_layout
DebugManager.log_info("[%s] Loading saved grid state: size(%d,%d), %d tile types, layout_size=%d" % [instance_id, saved_size.x, saved_size.y, TILE_TYPES, saved_layout.size()], "Match3")
DebugManager.log_info(
(
"[%s] Loading saved grid state: size(%d,%d), %d tile types, layout_size=%d"
% [instance_id, saved_size.x, saved_size.y, TILE_TYPES, saved_layout.size()]
),
"Match3"
)
# Debug: Print first few rows of loaded layout
for y in range(min(3, saved_layout.size())):
@@ -806,11 +996,23 @@ func load_saved_state() -> bool:
# Validate saved data
if saved_layout.size() != saved_size.y:
DebugManager.log_error("Saved grid layout height mismatch: expected %d, got %d" % [saved_size.y, saved_layout.size()], "Match3")
DebugManager.log_error(
(
"Saved grid layout height mismatch: expected %d, got %d"
% [saved_size.y, saved_layout.size()]
),
"Match3"
)
return false
if saved_layout.size() > 0 and saved_layout[0].size() != saved_size.x:
DebugManager.log_error("Saved grid layout width mismatch: expected %d, got %d" % [saved_size.x, saved_layout[0].size()], "Match3")
DebugManager.log_error(
(
"Saved grid layout width mismatch: expected %d, got %d"
% [saved_size.x, saved_layout[0].size()]
),
"Match3"
)
return false
# Apply the saved settings
@@ -819,7 +1021,10 @@ func load_saved_state() -> bool:
# Recalculate layout if size changed
if old_size != saved_size:
DebugManager.log_info("Grid size changed from %s to %s, recalculating layout" % [old_size, saved_size], "Match3")
DebugManager.log_info(
"Grid size changed from %s to %s, recalculating layout" % [old_size, saved_size],
"Match3"
)
_calculate_grid_layout()
await _restore_grid_from_layout(saved_layout, saved_gems)
@@ -827,8 +1032,15 @@ func load_saved_state() -> bool:
DebugManager.log_info("Successfully loaded saved grid state", "Match3")
return true
func _restore_grid_from_layout(grid_layout: Array, active_gems: Array):
DebugManager.log_info("[%s] Starting grid restoration: layout_size=%d, active_gems=%s" % [instance_id, grid_layout.size(), active_gems], "Match3")
func _restore_grid_from_layout(grid_layout: Array, active_gems: Array[int]) -> void:
DebugManager.log_info(
(
"[%s] Starting grid restoration: layout_size=%d, active_gems=%s"
% [instance_id, grid_layout.size(), active_gems]
),
"Match3"
)
# Clear ALL existing tile children, not just ones in grid array
# This ensures no duplicate layers are created
@@ -839,7 +1051,9 @@ func _restore_grid_from_layout(grid_layout: Array, active_gems: Array):
if script_path == "res://scenes/game/gameplays/tile.gd":
all_tile_children.append(child)
DebugManager.log_debug("Found %d existing tile children to remove" % all_tile_children.size(), "Match3")
DebugManager.log_debug(
"Found %d existing tile children to remove" % all_tile_children.size(), "Match3"
)
# Remove all found tile children
for child in all_tile_children:
@@ -872,26 +1086,44 @@ func _restore_grid_from_layout(grid_layout: Array, active_gems: Array):
# Set the saved tile type
var saved_tile_type = grid_layout[y][x]
DebugManager.log_debug("Setting tile (%d,%d): saved_type=%d, TILE_TYPES=%d" % [x, y, saved_tile_type, TILE_TYPES], "Match3")
DebugManager.log_debug(
(
"Setting tile (%d,%d): saved_type=%d, TILE_TYPES=%d"
% [x, y, saved_tile_type, TILE_TYPES]
),
"Match3"
)
if saved_tile_type >= 0 and saved_tile_type < TILE_TYPES:
tile.tile_type = saved_tile_type
DebugManager.log_debug("✓ Restored tile (%d,%d) with saved type %d" % [x, y, saved_tile_type], "Match3")
DebugManager.log_debug(
"✓ Restored tile (%d,%d) with saved type %d" % [x, y, saved_tile_type], "Match3"
)
else:
# Fallback for invalid tile types
tile.tile_type = randi() % TILE_TYPES
DebugManager.log_error("✗ Invalid saved tile type %d at (%d,%d), using random %d" % [saved_tile_type, x, y, tile.tile_type], "Match3")
DebugManager.log_error(
(
"✗ Invalid saved tile type %d at (%d,%d), using random %d"
% [saved_tile_type, x, y, tile.tile_type]
),
"Match3"
)
# Connect tile signals
tile.tile_selected.connect(_on_tile_selected)
grid[y].append(tile)
DebugManager.log_info("Completed grid restoration: %d tiles restored" % [GRID_SIZE.x * GRID_SIZE.y], "Match3")
DebugManager.log_info(
"Completed grid restoration: %d tiles restored" % [GRID_SIZE.x * GRID_SIZE.y], "Match3"
)
# Safety and validation helper functions
func _is_valid_grid_position(pos: Vector2i) -> bool:
return pos.x >= 0 and pos.y >= 0 and pos.x < GRID_SIZE.x and pos.y < GRID_SIZE.y
func _validate_grid_integrity() -> bool:
# Check if grid array structure is valid
if not grid is Array:
@@ -899,7 +1131,9 @@ func _validate_grid_integrity() -> bool:
return false
if grid.size() != GRID_SIZE.y:
DebugManager.log_error("Grid height mismatch: %d vs %d" % [grid.size(), GRID_SIZE.y], "Match3")
DebugManager.log_error(
"Grid height mismatch: %d vs %d" % [grid.size(), GRID_SIZE.y], "Match3"
)
return false
for y in range(grid.size()):
@@ -908,11 +1142,14 @@ func _validate_grid_integrity() -> bool:
return false
if grid[y].size() != GRID_SIZE.x:
DebugManager.log_error("Grid row %d width mismatch: %d vs %d" % [y, grid[y].size(), GRID_SIZE.x], "Match3")
DebugManager.log_error(
"Grid row %d width mismatch: %d vs %d" % [y, grid[y].size(), GRID_SIZE.x], "Match3"
)
return false
return true
func _safe_grid_access(pos: Vector2i) -> Node2D:
# Safe grid access with comprehensive bounds checking
if not _is_valid_grid_position(pos):
@@ -928,6 +1165,7 @@ func _safe_grid_access(pos: Vector2i) -> Node2D:
return tile
func _safe_tile_access(tile: Node2D, property: String):
# Safe property access on tiles
if not tile or not is_instance_valid(tile):

150
scenes/game/gameplays/tile.gd
View File

@@ -2,10 +2,13 @@ extends Node2D
signal tile_selected(tile: Node2D)
@export var tile_type: int = 0 : set = _set_tile_type
@export var tile_type: int = 0:
set = _set_tile_type
var grid_position: Vector2i
var is_selected: bool = false : set = _set_selected
var is_highlighted: bool = false : set = _set_highlighted
var is_selected: bool = false:
set = _set_selected
var is_highlighted: bool = false:
set = _set_highlighted
var original_scale: Vector2 = Vector2.ONE # Store the original scale for the board
@onready var sprite: Sprite2D = $Sprite2D
@@ -14,19 +17,20 @@ var original_scale: Vector2 = Vector2.ONE # Store the original scale for the bo
const TILE_SIZE = 48 # Slightly smaller than 54 to leave some padding
# All available gem textures
var all_gem_textures = [
preload("res://assets/sprites/gems/bg_19.png"), # 0 - Blue gem
preload("res://assets/sprites/gems/dg_19.png"), # 1 - Dark gem
preload("res://assets/sprites/gems/gg_19.png"), # 2 - Green gem
preload("res://assets/sprites/gems/mg_19.png"), # 3 - Magenta gem
preload("res://assets/sprites/gems/rg_19.png"), # 4 - Red gem
preload("res://assets/sprites/gems/yg_19.png"), # 5 - Yellow gem
preload("res://assets/sprites/gems/pg_19.png"), # 6 - Purple gem
preload("res://assets/sprites/gems/sg_19.png"), # 7 - Silver gem
var all_gem_textures: Array[Texture2D] = [
preload("res://assets/sprites/gems/bg_19.png"), # 0 - Blue gem
preload("res://assets/sprites/gems/dg_19.png"), # 1 - Dark gem
preload("res://assets/sprites/gems/gg_19.png"), # 2 - Green gem
preload("res://assets/sprites/gems/mg_19.png"), # 3 - Magenta gem
preload("res://assets/sprites/gems/rg_19.png"), # 4 - Red gem
preload("res://assets/sprites/gems/yg_19.png"), # 5 - Yellow gem
preload("res://assets/sprites/gems/pg_19.png"), # 6 - Purple gem
preload("res://assets/sprites/gems/sg_19.png"), # 7 - Silver gem
]
# Currently active gem types (indices into all_gem_textures)
var active_gem_types = [] # Will be set from TileManager
var active_gem_types: Array[int] = [] # Will be set from TileManager
func _set_tile_type(value: int) -> void:
tile_type = value
@@ -38,7 +42,16 @@ func _set_tile_type(value: int) -> void:
sprite.texture = all_gem_textures[texture_index]
_scale_sprite_to_fit()
else:
DebugManager.log_error("Invalid tile type: " + str(value) + ". Available types: 0-" + str(active_gem_types.size() - 1), "Match3")
DebugManager.log_error(
(
"Invalid tile type: "
+ str(value)
+ ". Available types: 0-"
+ str(active_gem_types.size() - 1)
),
"Match3"
)
func _scale_sprite_to_fit() -> void:
# Fixed: Add additional null checks
@@ -48,9 +61,16 @@ func _scale_sprite_to_fit() -> void:
var scale_factor = TILE_SIZE / max_dimension
original_scale = Vector2(scale_factor, scale_factor)
sprite.scale = original_scale
DebugManager.log_debug("Set original scale to %s for tile (%d,%d)" % [original_scale, grid_position.x, grid_position.y], "Match3")
DebugManager.log_debug(
(
"Set original scale to %s for tile (%d,%d)"
% [original_scale, grid_position.x, grid_position.y]
),
"Match3"
)
func set_active_gem_types(gem_indices: Array) -> void:
func set_active_gem_types(gem_indices: Array[int]) -> void:
if not gem_indices or gem_indices.is_empty():
DebugManager.log_error("Empty gem indices array provided", "Tile")
return
@@ -60,7 +80,13 @@ func set_active_gem_types(gem_indices: Array) -> void:
# Validate all gem indices are within bounds
for gem_index in active_gem_types:
if gem_index < 0 or gem_index >= all_gem_textures.size():
DebugManager.log_error("Invalid gem index: %d (valid range: 0-%d)" % [gem_index, all_gem_textures.size() - 1], "Tile")
DebugManager.log_error(
(
"Invalid gem index: %d (valid range: 0-%d)"
% [gem_index, all_gem_textures.size() - 1]
),
"Tile"
)
# Use default fallback
active_gem_types = [0, 1, 2, 3, 4]
break
@@ -72,9 +98,11 @@ func set_active_gem_types(gem_indices: Array) -> void:
_set_tile_type(tile_type)
func get_active_gem_count() -> int:
return active_gem_types.size()
func add_gem_type(gem_index: int) -> bool:
if gem_index < 0 or gem_index >= all_gem_textures.size():
DebugManager.log_error("Invalid gem index: %d" % gem_index, "Tile")
@@ -86,6 +114,7 @@ func add_gem_type(gem_index: int) -> bool:
return false
func remove_gem_type(gem_index: int) -> bool:
var type_index = active_gem_types.find(gem_index)
if type_index == -1:
@@ -104,18 +133,33 @@ func remove_gem_type(gem_index: int) -> bool:
return true
func _set_selected(value: bool) -> void:
var old_value = is_selected
is_selected = value
DebugManager.log_debug("Tile (%d,%d) selection changed: %s -> %s" % [grid_position.x, grid_position.y, old_value, value], "Match3")
DebugManager.log_debug(
(
"Tile (%d,%d) selection changed: %s -> %s"
% [grid_position.x, grid_position.y, old_value, value]
),
"Match3"
)
_update_visual_feedback()
func _set_highlighted(value: bool) -> void:
var old_value = is_highlighted
is_highlighted = value
DebugManager.log_debug("Tile (%d,%d) highlight changed: %s -> %s" % [grid_position.x, grid_position.y, old_value, value], "Match3")
DebugManager.log_debug(
(
"Tile (%d,%d) highlight changed: %s -> %s"
% [grid_position.x, grid_position.y, old_value, value]
),
"Match3"
)
_update_visual_feedback()
func _update_visual_feedback() -> void:
if not sprite:
return
@@ -129,17 +173,35 @@ func _update_visual_feedback() -> void:
# Selected: bright and 20% larger than original board size
target_modulate = Color(1.2, 1.2, 1.2, 1.0)
scale_multiplier = 1.2
DebugManager.log_debug("SELECTING tile (%d,%d): target scale %.2fx, current scale %s" % [grid_position.x, grid_position.y, scale_multiplier, sprite.scale], "Match3")
DebugManager.log_debug(
(
"SELECTING tile (%d,%d): target scale %.2fx, current scale %s"
% [grid_position.x, grid_position.y, scale_multiplier, sprite.scale]
),
"Match3"
)
elif is_highlighted:
# Highlighted: subtle glow and 10% larger than original board size
target_modulate = Color(1.1, 1.1, 1.1, 1.0)
scale_multiplier = 1.1
DebugManager.log_debug("HIGHLIGHTING tile (%d,%d): target scale %.2fx, current scale %s" % [grid_position.x, grid_position.y, scale_multiplier, sprite.scale], "Match3")
DebugManager.log_debug(
(
"HIGHLIGHTING tile (%d,%d): target scale %.2fx, current scale %s"
% [grid_position.x, grid_position.y, scale_multiplier, sprite.scale]
),
"Match3"
)
else:
# Normal state: white and original board size
target_modulate = Color.WHITE
scale_multiplier = 1.0
DebugManager.log_debug("NORMALIZING tile (%d,%d): target scale %.2fx, current scale %s" % [grid_position.x, grid_position.y, scale_multiplier, sprite.scale], "Match3")
DebugManager.log_debug(
(
"NORMALIZING tile (%d,%d): target scale %.2fx, current scale %s"
% [grid_position.x, grid_position.y, scale_multiplier, sprite.scale]
),
"Match3"
)
# Calculate target scale relative to original board scale
target_scale = original_scale * scale_multiplier
@@ -149,7 +211,13 @@ func _update_visual_feedback() -> void:
# Only animate scale if it's actually changing
if sprite.scale != target_scale:
DebugManager.log_debug("Animating scale from %s to %s for tile (%d,%d)" % [sprite.scale, target_scale, grid_position.x, grid_position.y], "Match3")
DebugManager.log_debug(
(
"Animating scale from %s to %s for tile (%d,%d)"
% [sprite.scale, target_scale, grid_position.x, grid_position.y]
),
"Match3"
)
var tween = create_tween()
tween.tween_property(sprite, "scale", target_scale, 0.15)
@@ -157,10 +225,20 @@ func _update_visual_feedback() -> void:
# Add completion callback for debugging
tween.tween_callback(_on_scale_animation_completed.bind(target_scale))
else:
DebugManager.log_debug("No scale change needed for tile (%d,%d)" % [grid_position.x, grid_position.y], "Match3")
DebugManager.log_debug(
"No scale change needed for tile (%d,%d)" % [grid_position.x, grid_position.y], "Match3"
)
func _on_scale_animation_completed(expected_scale: Vector2) -> void:
DebugManager.log_debug("Scale animation completed for tile (%d,%d): expected %s, actual %s" % [grid_position.x, grid_position.y, expected_scale, sprite.scale], "Match3")
DebugManager.log_debug(
(
"Scale animation completed for tile (%d,%d): expected %s, actual %s"
% [grid_position.x, grid_position.y, expected_scale, sprite.scale]
),
"Match3"
)
func force_reset_visual_state() -> void:
# Force reset all visual states - debug function
@@ -169,7 +247,27 @@ func force_reset_visual_state() -> void:
if sprite:
sprite.modulate = Color.WHITE
sprite.scale = original_scale # Reset to original board scale, not 1.0
DebugManager.log_debug("Forced visual reset on tile (%d,%d) to original scale %s" % [grid_position.x, grid_position.y, original_scale], "Match3")
DebugManager.log_debug(
(
"Forced visual reset on tile (%d,%d) to original scale %s"
% [grid_position.x, grid_position.y, original_scale]
),
"Match3"
)
# Handle input for tile selection
func _input(event: InputEvent) -> void:
if event is InputEventMouseButton:
if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
# Check if the mouse click is within the tile's bounds
var local_position = to_local(get_global_mouse_position())
var sprite_rect = Rect2(-TILE_SIZE / 2.0, -TILE_SIZE / 2.0, TILE_SIZE, TILE_SIZE)
if sprite_rect.has_point(local_position):
tile_selected.emit(self)
get_viewport().set_input_as_handled()
# Called when the node enters the scene tree for the first time.
func _ready() -> void: