307 lines
11 KiB
GDScript
307 lines
11 KiB
GDScript
extends Node
|
|
|
|
# SpecialTilesManager - Handles special effects triggered by holo tile pickups
|
|
|
|
# Holo tile indices (11-14) trigger special effects
|
|
const HOLO_TILES = [11, 12, 13, 14]
|
|
|
|
enum SpecialEffect {
|
|
BURN_TILES, # Remove 3x3 pattern tiles on random opponent
|
|
SPAWN_TILES, # Spawn 3x3 pattern tiles around activating player
|
|
FREEZE_PLAYER, # Freeze random opponent for 3 seconds
|
|
BLOCK_FLOOR, # Make nearby tile non-walkable for 9 seconds
|
|
INVISIBLE_MODE # Speed boost + auto-grab + shield for 6 seconds
|
|
}
|
|
|
|
# Random shape patterns for 3x3 area (relative offsets from center)
|
|
const PATTERNS = {
|
|
"T": [Vector2i(0, -1), Vector2i(-1, 0), Vector2i(0, 0), Vector2i(1, 0)],
|
|
"L": [Vector2i(0, -1), Vector2i(0, 0), Vector2i(0, 1), Vector2i(1, 1)],
|
|
"I_H": [Vector2i(-1, 0), Vector2i(0, 0), Vector2i(1, 0)],
|
|
"I_V": [Vector2i(0, -1), Vector2i(0, 0), Vector2i(0, 1)],
|
|
"PLUS": [Vector2i(0, -1), Vector2i(-1, 0), Vector2i(0, 0), Vector2i(1, 0), Vector2i(0, 1)],
|
|
"CORNER": [Vector2i(-1, -1), Vector2i(0, -1), Vector2i(-1, 0), Vector2i(0, 0)],
|
|
"FULL": [Vector2i(-1, -1), Vector2i(0, -1), Vector2i(1, -1), Vector2i(-1, 0), Vector2i(0, 0), Vector2i(1, 0), Vector2i(-1, 1), Vector2i(0, 1)],
|
|
"DOT3": [Vector2i(-1, 0), Vector2i(0, 0), Vector2i(1, 0)]
|
|
}
|
|
|
|
var player: Node3D
|
|
var enhanced_gridmap: Node
|
|
var rng: RandomNumberGenerator
|
|
|
|
# Effect durations
|
|
const FREEZE_DURATION = 3.0
|
|
const BLOCK_DURATION = 9.0
|
|
const INVISIBLE_DURATION = 6.0
|
|
|
|
# Active effect tracking
|
|
var blocked_tiles: Array[Dictionary] = [] # {position: Vector3i, original_item: int, timer: float}
|
|
|
|
func initialize(p_player: Node3D, p_gridmap: Node):
|
|
player = p_player
|
|
enhanced_gridmap = p_gridmap
|
|
rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
func _process(delta):
|
|
_update_blocked_tiles(delta)
|
|
|
|
# =============================================================================
|
|
# Check if item is a holo tile
|
|
# =============================================================================
|
|
|
|
func is_holo_tile(item_id: int) -> bool:
|
|
return item_id in HOLO_TILES
|
|
|
|
# =============================================================================
|
|
# Trigger random special effect
|
|
# =============================================================================
|
|
|
|
func trigger_random_effect():
|
|
var effect = rng.randi() % SpecialEffect.size()
|
|
|
|
print("[SpecialTiles] Player %s triggered effect: %s" % [player.name, SpecialEffect.keys()[effect]])
|
|
|
|
match effect:
|
|
SpecialEffect.BURN_TILES:
|
|
_execute_burn_tiles()
|
|
SpecialEffect.SPAWN_TILES:
|
|
_execute_spawn_tiles()
|
|
SpecialEffect.FREEZE_PLAYER:
|
|
_execute_freeze_player()
|
|
SpecialEffect.BLOCK_FLOOR:
|
|
_execute_block_floor()
|
|
SpecialEffect.INVISIBLE_MODE:
|
|
_execute_invisible_mode()
|
|
|
|
# Sync effect to all clients
|
|
if player.is_multiplayer_authority():
|
|
rpc("sync_effect_triggered", effect)
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func sync_effect_triggered(effect: int):
|
|
print("[SpecialTiles] Synced effect %s for player %s" % [SpecialEffect.keys()[effect], player.name])
|
|
|
|
# =============================================================================
|
|
# Pattern Generation
|
|
# =============================================================================
|
|
|
|
func _get_random_pattern() -> Array[Vector2i]:
|
|
var pattern_keys = PATTERNS.keys()
|
|
var selected_pattern = pattern_keys[rng.randi() % pattern_keys.size()]
|
|
var base_pattern = PATTERNS[selected_pattern].duplicate()
|
|
|
|
# Randomly rotate pattern (0, 90, 180, 270 degrees)
|
|
var rotations = rng.randi() % 4
|
|
for i in range(rotations):
|
|
for j in range(base_pattern.size()):
|
|
var p = base_pattern[j]
|
|
base_pattern[j] = Vector2i(-p.y, p.x) # 90 degree rotation
|
|
|
|
# Ensure pattern has 3-8 cells
|
|
var result: Array[Vector2i] = []
|
|
for offset in base_pattern:
|
|
result.append(offset)
|
|
|
|
return result
|
|
|
|
func _get_valid_pattern_positions(center: Vector2i, pattern: Array[Vector2i]) -> Array[Vector2i]:
|
|
var valid_positions: Array[Vector2i] = []
|
|
|
|
for offset in pattern:
|
|
var pos = center + offset
|
|
if enhanced_gridmap.is_position_valid(pos):
|
|
valid_positions.append(pos)
|
|
|
|
return valid_positions
|
|
|
|
# =============================================================================
|
|
# Effect Implementations
|
|
# =============================================================================
|
|
|
|
func _execute_burn_tiles():
|
|
# Find random opponent
|
|
var opponent = _get_random_opponent()
|
|
if not opponent:
|
|
print("[SpecialTiles] No opponent found for BURN_TILES")
|
|
return
|
|
|
|
# Get pattern around opponent
|
|
var pattern = _get_random_pattern()
|
|
var positions = _get_valid_pattern_positions(opponent.current_position, pattern)
|
|
|
|
# Remove tiles at these positions
|
|
for pos in positions:
|
|
var cell = Vector3i(pos.x, 1, pos.y)
|
|
if enhanced_gridmap.get_cell_item(cell) != -1:
|
|
if player.is_multiplayer_authority():
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
|
|
|
|
# Trigger screen shake on the targeted opponent
|
|
if opponent.is_multiplayer_authority():
|
|
opponent.rpc("trigger_screen_shake", "targeted")
|
|
else:
|
|
opponent.rpc_id(opponent.get_multiplayer_authority(), "trigger_screen_shake", "targeted")
|
|
|
|
print("[SpecialTiles] BURN_TILES: Removed %d tiles around %s" % [positions.size(), opponent.name])
|
|
player.rpc("display_message", "Burned tiles near opponent!")
|
|
|
|
func _execute_spawn_tiles():
|
|
# Get pattern around activating player
|
|
var pattern = _get_random_pattern()
|
|
var positions = _get_valid_pattern_positions(player.current_position, pattern)
|
|
|
|
# Spawn random tiles at empty positions
|
|
var spawned_count = 0
|
|
for pos in positions:
|
|
var cell = Vector3i(pos.x, 1, pos.y)
|
|
if enhanced_gridmap.get_cell_item(cell) == -1:
|
|
var new_tile = rng.randi_range(7, 10) # Random normal tile
|
|
if player.is_multiplayer_authority():
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_grid_item", cell.x, cell.y, cell.z, new_tile)
|
|
spawned_count += 1
|
|
|
|
print("[SpecialTiles] SPAWN_TILES: Spawned %d tiles around %s" % [spawned_count, player.name])
|
|
player.rpc("display_message", "Spawned new tiles!")
|
|
|
|
func _execute_freeze_player():
|
|
# Find random opponent
|
|
var opponent = _get_random_opponent()
|
|
if not opponent:
|
|
print("[SpecialTiles] No opponent found for FREEZE_PLAYER")
|
|
return
|
|
|
|
# Freeze the opponent
|
|
if opponent.has_method("apply_freeze"):
|
|
opponent.apply_freeze(FREEZE_DURATION)
|
|
else:
|
|
# Fallback: directly set frozen state
|
|
opponent.set("is_frozen", true)
|
|
_create_unfreeze_timer(opponent, FREEZE_DURATION)
|
|
|
|
# Trigger screen shake on the frozen opponent
|
|
if opponent.is_multiplayer_authority():
|
|
opponent.rpc("trigger_screen_shake", "targeted")
|
|
else:
|
|
opponent.rpc_id(opponent.get_multiplayer_authority(), "trigger_screen_shake", "targeted")
|
|
|
|
print("[SpecialTiles] FREEZE_PLAYER: Froze %s for %ds" % [opponent.name, FREEZE_DURATION])
|
|
player.rpc("display_message", "Froze an opponent!")
|
|
opponent.rpc("display_message", "You are frozen!")
|
|
|
|
func _create_unfreeze_timer(target_player: Node3D, duration: float):
|
|
await player.get_tree().create_timer(duration).timeout
|
|
if is_instance_valid(target_player):
|
|
target_player.set("is_frozen", false)
|
|
target_player.rpc("display_message", "Unfrozen!")
|
|
|
|
func _execute_block_floor():
|
|
# Find valid tile near player to block
|
|
var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
|
|
var valid_neighbors = neighbors.filter(func(n): return n.is_walkable)
|
|
|
|
if valid_neighbors.is_empty():
|
|
print("[SpecialTiles] No valid tile to block")
|
|
return
|
|
|
|
var target_neighbor = valid_neighbors[rng.randi() % valid_neighbors.size()]
|
|
var block_pos = Vector3i(target_neighbor.position.x, 0, target_neighbor.position.y)
|
|
var original_item = enhanced_gridmap.get_cell_item(block_pos)
|
|
|
|
# Make tile non-walkable (use a blocked item index)
|
|
var blocked_item = 4 # Using non_walkable_items[0] typically
|
|
if enhanced_gridmap.non_walkable_items.size() > 0:
|
|
blocked_item = enhanced_gridmap.non_walkable_items[0]
|
|
|
|
if player.is_multiplayer_authority():
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_grid_item", block_pos.x, block_pos.y, block_pos.z, blocked_item)
|
|
|
|
# Track blocked tile for restoration
|
|
blocked_tiles.append({
|
|
"position": block_pos,
|
|
"original_item": original_item,
|
|
"timer": BLOCK_DURATION
|
|
})
|
|
|
|
# Re-initialize pathfinding
|
|
enhanced_gridmap.initialize_astar()
|
|
|
|
print("[SpecialTiles] BLOCK_FLOOR: Blocked tile at %s for %ds" % [target_neighbor.position, BLOCK_DURATION])
|
|
player.rpc("display_message", "Blocked a floor tile!")
|
|
|
|
func _execute_invisible_mode():
|
|
# Set invisible mode on player
|
|
if player.has_method("apply_invisible_mode"):
|
|
player.apply_invisible_mode(INVISIBLE_DURATION)
|
|
else:
|
|
# Fallback: directly set invisible state
|
|
player.set("is_invisible", true)
|
|
player.set("original_movement_range", player.movement_range)
|
|
player.movement_range = player.movement_range + 2 # Speed boost
|
|
_create_invisibility_timer(INVISIBLE_DURATION)
|
|
|
|
print("[SpecialTiles] INVISIBLE_MODE: %s is now invisible for %ds" % [player.name, INVISIBLE_DURATION])
|
|
player.rpc("display_message", "Invisible mode activated!")
|
|
|
|
func _create_invisibility_timer(duration: float):
|
|
await player.get_tree().create_timer(duration).timeout
|
|
if is_instance_valid(player):
|
|
player.set("is_invisible", false)
|
|
if player.get("original_movement_range"):
|
|
player.movement_range = player.original_movement_range
|
|
player.rpc("display_message", "Invisible mode ended!")
|
|
|
|
# =============================================================================
|
|
# Helper Functions
|
|
# =============================================================================
|
|
|
|
func _get_random_opponent() -> Node3D:
|
|
var all_players = player.get_tree().get_nodes_in_group("Players")
|
|
var opponents = all_players.filter(func(p): return p != player)
|
|
|
|
if opponents.is_empty():
|
|
return null
|
|
|
|
return opponents[rng.randi() % opponents.size()]
|
|
|
|
func _update_blocked_tiles(delta: float):
|
|
var tiles_to_restore: Array[int] = []
|
|
|
|
for i in range(blocked_tiles.size()):
|
|
blocked_tiles[i].timer -= delta
|
|
if blocked_tiles[i].timer <= 0:
|
|
tiles_to_restore.append(i)
|
|
|
|
# Restore tiles in reverse order to maintain indices
|
|
tiles_to_restore.reverse()
|
|
for idx in tiles_to_restore:
|
|
var tile_data = blocked_tiles[idx]
|
|
if player.is_multiplayer_authority():
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_grid_item", tile_data.position.x, tile_data.position.y, tile_data.position.z, tile_data.original_item)
|
|
blocked_tiles.remove_at(idx)
|
|
|
|
if tiles_to_restore.size() > 0:
|
|
enhanced_gridmap.initialize_astar()
|
|
|
|
# =============================================================================
|
|
# Shield Check (for Invisible Mode)
|
|
# =============================================================================
|
|
|
|
func check_shield_and_cancel_effect() -> bool:
|
|
"""Returns true if player has shield (invisible mode) and cancels the incoming effect."""
|
|
if player.get("is_invisible"):
|
|
player.set("is_invisible", false)
|
|
if player.get("original_movement_range"):
|
|
player.movement_range = player.original_movement_range
|
|
player.rpc("display_message", "Shield blocked an attack!")
|
|
return true
|
|
return false
|