make grid shuffle, grid sizy, gem color types
This commit is contained in:
@@ -1,26 +1,71 @@
|
||||
extends Node2D
|
||||
|
||||
const GRID_SIZE := Vector2i(8, 8)
|
||||
const TILE_TYPES := 5
|
||||
var GRID_SIZE := Vector2i(8, 8)
|
||||
var TILE_TYPES := 5
|
||||
const TILE_SCENE := preload("res://scenes/match3/tile.tscn")
|
||||
|
||||
var grid := []
|
||||
var tile_size: float = 48.0
|
||||
var grid_offset: Vector2
|
||||
|
||||
func _ready():
|
||||
# Set up initial gem pool
|
||||
var gem_indices = []
|
||||
for i in range(TILE_TYPES):
|
||||
gem_indices.append(i)
|
||||
|
||||
const TileScript = preload("res://scenes/match3/tile.gd")
|
||||
TileScript.set_active_gem_pool(gem_indices)
|
||||
|
||||
_calculate_grid_layout()
|
||||
_initialize_grid()
|
||||
|
||||
func _calculate_grid_layout():
|
||||
var viewport_size = get_viewport().get_visible_rect().size
|
||||
var available_width = viewport_size.x * 0.8 # Use 80% of screen width
|
||||
var available_height = viewport_size.y * 0.7 # Use 70% of screen height
|
||||
|
||||
# Calculate tile size based on available space
|
||||
var max_tile_width = available_width / GRID_SIZE.x
|
||||
var max_tile_height = available_height / GRID_SIZE.y
|
||||
tile_size = min(max_tile_width, max_tile_height)
|
||||
|
||||
# Align grid to left side with some margin
|
||||
var total_grid_height = tile_size * GRID_SIZE.y
|
||||
grid_offset = Vector2(
|
||||
50, # Left margin
|
||||
(viewport_size.y - total_grid_height) / 2 + 50 # Vertically centered with top margin
|
||||
)
|
||||
|
||||
func _initialize_grid():
|
||||
# Update gem pool BEFORE creating any tiles
|
||||
var gem_indices = []
|
||||
for i in range(TILE_TYPES):
|
||||
gem_indices.append(i)
|
||||
|
||||
const TileScript = preload("res://scenes/match3/tile.gd")
|
||||
TileScript.set_active_gem_pool(gem_indices)
|
||||
|
||||
for y in range(GRID_SIZE.y):
|
||||
grid.append([])
|
||||
for x in range(GRID_SIZE.x):
|
||||
var tile = TILE_SCENE.instantiate()
|
||||
tile.position = Vector2(x, y) * 64 # Adjust to your tile size
|
||||
tile.position = grid_offset + Vector2(x, y) * tile_size
|
||||
tile.grid_position = Vector2i(x, y)
|
||||
tile.tile_type = randi() % TILE_TYPES
|
||||
add_child(tile)
|
||||
# Set tile type after adding to scene tree so sprite reference is available
|
||||
var new_type = randi() % TILE_TYPES
|
||||
tile.tile_type = new_type
|
||||
print("Debug: Created tile at (", x, ",", y, ") with type ", new_type)
|
||||
grid[y].append(tile)
|
||||
|
||||
func _has_match_at(pos: Vector2i) -> bool:
|
||||
# Fixed: Add bounds and null checks
|
||||
if pos.x < 0 or pos.y < 0 or pos.x >= GRID_SIZE.x or pos.y >= GRID_SIZE.y:
|
||||
return false
|
||||
if not grid[pos.y][pos.x]:
|
||||
return false
|
||||
|
||||
var matches_horizontal = _get_match_line(pos, Vector2i(1, 0))
|
||||
if matches_horizontal.size() >= 3:
|
||||
return true
|
||||
@@ -28,15 +73,25 @@ func _has_match_at(pos: Vector2i) -> bool:
|
||||
var matches_vertical = _get_match_line(pos, Vector2i(0, 1))
|
||||
return matches_vertical.size() >= 3
|
||||
|
||||
# Fixed: Add missing function to check for any matches on the board
|
||||
func _check_for_matches() -> bool:
|
||||
for y in range(GRID_SIZE.y):
|
||||
for x in range(GRID_SIZE.x):
|
||||
if _has_match_at(Vector2i(x, y)):
|
||||
return true
|
||||
return false
|
||||
|
||||
func _get_match_line(start: Vector2i, dir: Vector2i) -> Array:
|
||||
var line = [grid[start.y][start.x]]
|
||||
var type = grid[start.y][start.x].tile_type
|
||||
|
||||
# Fixed: Check in both directions separately to avoid infinite loops
|
||||
for offset in [1, -1]:
|
||||
var current = start + dir * offset
|
||||
while current.x >= 0 and current.y >= 0 and current.x < GRID_SIZE.x and current.y < GRID_SIZE.y:
|
||||
var neighbor = grid[current.y][current.x]
|
||||
if neighbor.tile_type != type:
|
||||
# Fixed: Add null check to prevent crashes
|
||||
if not neighbor or neighbor.tile_type != type:
|
||||
break
|
||||
line.append(neighbor)
|
||||
current += dir * offset
|
||||
@@ -48,6 +103,9 @@ func _clear_matches():
|
||||
|
||||
for y in range(GRID_SIZE.y):
|
||||
for x in range(GRID_SIZE.x):
|
||||
# Fixed: Add null check before processing
|
||||
if not grid[y][x]:
|
||||
continue
|
||||
var pos = Vector2i(x, y)
|
||||
var horiz = _get_match_line(pos, Vector2i(1, 0))
|
||||
if horiz.size() >= 3:
|
||||
@@ -62,6 +120,10 @@ func _clear_matches():
|
||||
unique_dict[tile] = true
|
||||
to_clear = unique_dict.keys()
|
||||
|
||||
# Fixed: Only proceed if there are matches to clear
|
||||
if to_clear.size() == 0:
|
||||
return
|
||||
|
||||
for tile in to_clear:
|
||||
grid[tile.grid_position.y][tile.grid_position.x] = null
|
||||
tile.queue_free()
|
||||
@@ -75,15 +137,17 @@ func _drop_tiles():
|
||||
while moved:
|
||||
moved = false
|
||||
for x in range(GRID_SIZE.x):
|
||||
for y in range(GRID_SIZE.y - 2, -1, -1):
|
||||
# Fixed: Start from GRID_SIZE.y - 1 to avoid out of bounds
|
||||
for y in range(GRID_SIZE.y - 1, -1, -1):
|
||||
var tile = grid[y][x]
|
||||
if tile and not grid[y + 1][x]:
|
||||
# Fixed: Check bounds before accessing y + 1
|
||||
if tile and y + 1 < GRID_SIZE.y and not grid[y + 1][x]:
|
||||
grid[y + 1][x] = tile
|
||||
grid[y][x] = null
|
||||
tile.grid_position = Vector2i(x, y + 1)
|
||||
# You can animate position here using Tween for smooth drop:
|
||||
# tween.interpolate_property(tile, "position", tile.position, Vector2(x, y + 1) * 64, 0.2)
|
||||
tile.position = Vector2(x, y + 1) * 64
|
||||
# tween.interpolate_property(tile, "position", tile.position, grid_offset + Vector2(x, y + 1) * tile_size, 0.2)
|
||||
tile.position = grid_offset + Vector2(x, y + 1) * tile_size
|
||||
moved = true
|
||||
|
||||
func _fill_empty_cells():
|
||||
@@ -93,10 +157,63 @@ func _fill_empty_cells():
|
||||
var tile = TILE_SCENE.instantiate()
|
||||
tile.grid_position = Vector2i(x, y)
|
||||
tile.tile_type = randi() % TILE_TYPES
|
||||
tile.position = Vector2(x, y) * 64
|
||||
tile.position = grid_offset + Vector2(x, y) * tile_size
|
||||
grid[y][x] = tile
|
||||
add_child(tile)
|
||||
|
||||
# Recheck matches
|
||||
# Fixed: Add recursion protection to prevent stack overflow
|
||||
await get_tree().create_timer(0.1).timeout
|
||||
_clear_matches()
|
||||
var max_iterations = 10
|
||||
var iteration = 0
|
||||
while _check_for_matches() and iteration < max_iterations:
|
||||
_clear_matches()
|
||||
await get_tree().create_timer(0.1).timeout
|
||||
iteration += 1
|
||||
|
||||
func regenerate_grid():
|
||||
# Use time-based seed to ensure different patterns each time
|
||||
var new_seed = Time.get_ticks_msec()
|
||||
seed(new_seed)
|
||||
print("Debug: Regenerating grid with seed: ", new_seed)
|
||||
|
||||
# Fixed: Clear ALL tile children, not just ones in grid array
|
||||
# This handles any orphaned tiles that might not be tracked in the grid
|
||||
var children_to_remove = []
|
||||
for child in get_children():
|
||||
if child.has_method("get_script") and child.get_script():
|
||||
var script_path = child.get_script().resource_path
|
||||
if script_path == "res://scenes/match3/tile.gd":
|
||||
children_to_remove.append(child)
|
||||
|
||||
# Remove all found tile children
|
||||
for child in children_to_remove:
|
||||
child.free()
|
||||
|
||||
# Also clear grid array references
|
||||
for y in range(grid.size()):
|
||||
if grid[y] and grid[y] is Array:
|
||||
for x in range(grid[y].size()):
|
||||
# Set to null since we already freed the nodes above
|
||||
grid[y][x] = null
|
||||
|
||||
# Clear the grid array
|
||||
grid.clear()
|
||||
|
||||
# No need to wait for nodes to be freed since we used free()
|
||||
|
||||
# Fixed: Recalculate grid layout before regenerating tiles
|
||||
_calculate_grid_layout()
|
||||
|
||||
# Regenerate the grid (gem pool is updated in _initialize_grid)
|
||||
_initialize_grid()
|
||||
|
||||
func set_tile_types(new_count: int):
|
||||
TILE_TYPES = new_count
|
||||
# Regenerate grid with new tile types (gem pool is updated in regenerate_grid)
|
||||
await regenerate_grid()
|
||||
|
||||
func set_grid_size(new_size: Vector2i):
|
||||
print("Debug: Changing grid size from ", GRID_SIZE, " to ", new_size)
|
||||
GRID_SIZE = new_size
|
||||
# Regenerate grid with new size
|
||||
await regenerate_grid()
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
extends Node2D
|
||||
|
||||
@export var tile_type: int = 0
|
||||
@export var tile_type: int = 0 : set = _set_tile_type
|
||||
var grid_position: Vector2i
|
||||
|
||||
@onready var sprite: Sprite2D = $Sprite2D
|
||||
@@ -20,20 +20,29 @@ var all_gem_textures = [
|
||||
preload("res://assets/sprites/gems/sg_19.png"), # 7 - Silver gem
|
||||
]
|
||||
|
||||
# Static variable to store the current gem pool for all tiles
|
||||
static var current_gem_pool = [0, 1, 2, 3, 4] # Start with first 5 gems
|
||||
|
||||
# Currently active gem types (indices into all_gem_textures)
|
||||
var active_gem_types = [0, 1, 2, 3, 4] # Start with first 5 gems
|
||||
var active_gem_types = [] # Will be set from current_gem_pool
|
||||
|
||||
func _set_tile_type(value: int) -> void:
|
||||
tile_type = value
|
||||
print("Debug: _set_tile_type called with value ", value, ", active_gem_types.size() = ", active_gem_types.size())
|
||||
# Fixed: Add sprite null check to prevent crashes during initialization
|
||||
if not sprite:
|
||||
return
|
||||
if value >= 0 and value < active_gem_types.size():
|
||||
var texture_index = active_gem_types[value]
|
||||
sprite.texture = all_gem_textures[texture_index]
|
||||
print("Debug: Set texture_index ", texture_index, " for tile_type ", value)
|
||||
_scale_sprite_to_fit()
|
||||
else:
|
||||
push_error("Invalid tile type: " + str(value) + ". Available types: 0-" + str(active_gem_types.size() - 1))
|
||||
|
||||
func _scale_sprite_to_fit() -> void:
|
||||
if sprite.texture:
|
||||
# Fixed: Add additional null checks
|
||||
if sprite and sprite.texture:
|
||||
var texture_size = sprite.texture.get_size()
|
||||
var max_dimension = max(texture_size.x, texture_size.y)
|
||||
var scale_factor = TILE_SIZE / max_dimension
|
||||
@@ -41,31 +50,41 @@ func _scale_sprite_to_fit() -> void:
|
||||
|
||||
# Gem pool management functions
|
||||
static func set_active_gem_pool(gem_indices: Array) -> void:
|
||||
# Update all tile instances to use new gem pool
|
||||
var tiles = get_tree().get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_update_active_gems"):
|
||||
tile._update_active_gems(gem_indices)
|
||||
# Update static gem pool for new tiles
|
||||
current_gem_pool = gem_indices.duplicate()
|
||||
|
||||
# Update all existing tile instances to use new gem pool
|
||||
var scene_tree = Engine.get_main_loop() as SceneTree
|
||||
if scene_tree:
|
||||
var tiles = scene_tree.get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_update_active_gems"):
|
||||
tile._update_active_gems(gem_indices)
|
||||
|
||||
func _update_active_gems(gem_indices: Array) -> void:
|
||||
active_gem_types = gem_indices.duplicate()
|
||||
# Re-validate current tile type
|
||||
if tile_type >= active_gem_types.size():
|
||||
tile_type = 0 # Reset to first available type
|
||||
# Generate a new random tile type within valid range
|
||||
tile_type = randi() % active_gem_types.size()
|
||||
_set_tile_type(tile_type)
|
||||
|
||||
static func get_active_gem_count() -> int:
|
||||
# Get from any tile instance or default
|
||||
var tiles = get_tree().get_nodes_in_group("tiles")
|
||||
if tiles.size() > 0:
|
||||
return tiles[0].active_gem_types.size()
|
||||
var scene_tree = Engine.get_main_loop() as SceneTree
|
||||
if scene_tree:
|
||||
var tiles = scene_tree.get_nodes_in_group("tiles")
|
||||
if tiles.size() > 0:
|
||||
return tiles[0].active_gem_types.size()
|
||||
return 5 # Default
|
||||
|
||||
static func add_gem_to_pool(gem_index: int) -> void:
|
||||
var tiles = get_tree().get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_add_gem_type"):
|
||||
tile._add_gem_type(gem_index)
|
||||
var scene_tree = Engine.get_main_loop() as SceneTree
|
||||
if scene_tree:
|
||||
var tiles = scene_tree.get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_add_gem_type"):
|
||||
tile._add_gem_type(gem_index)
|
||||
|
||||
func _add_gem_type(gem_index: int) -> void:
|
||||
if gem_index >= 0 and gem_index < all_gem_textures.size():
|
||||
@@ -73,10 +92,12 @@ func _add_gem_type(gem_index: int) -> void:
|
||||
active_gem_types.append(gem_index)
|
||||
|
||||
static func remove_gem_from_pool(gem_index: int) -> void:
|
||||
var tiles = get_tree().get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_remove_gem_type"):
|
||||
tile._remove_gem_type(gem_index)
|
||||
var scene_tree = Engine.get_main_loop() as SceneTree
|
||||
if scene_tree:
|
||||
var tiles = scene_tree.get_nodes_in_group("tiles")
|
||||
for tile in tiles:
|
||||
if tile.has_method("_remove_gem_type"):
|
||||
tile._remove_gem_type(gem_index)
|
||||
|
||||
func _remove_gem_type(gem_index: int) -> void:
|
||||
var type_index = active_gem_types.find(gem_index)
|
||||
@@ -90,4 +111,6 @@ func _remove_gem_type(gem_index: int) -> void:
|
||||
# Called when the node enters the scene tree for the first time.
|
||||
func _ready() -> void:
|
||||
add_to_group("tiles") # Add to group for gem pool management
|
||||
# Initialize with current static gem pool
|
||||
active_gem_types = current_gem_pool.duplicate()
|
||||
_set_tile_type(tile_type)
|
||||
|
||||
Reference in New Issue
Block a user