danchie/tekton
3
1
Fork 0
Code Issues 20 Pull Requests Actions Packages Projects 10 Releases 1 Wiki Activity
Files
6948a4aed1a1347395c4356cf4d6f26926d0bad1
tekton/scripts/managers/special_tiles_manager.gd
T
adtpdn 6948a4aed1 edit special power up
2026-01-09 22:41:00 +08:00

422 lines
16 KiB
GDScript
Raw Blame History

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}
var invisible_timer: float = 0.0
func initialize(p_player: Node3D, p_gridmap: Node):
player = p_player
enhanced_gridmap = p_gridmap
rng = RandomNumberGenerator.new()
rng.randomize()
# =============================================================================
# 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])
# =============================================================================
# Effect Implementations
# =============================================================================
func _execute_burn_tiles():
# NEW LOGIC: Put back random target tiles from their playerboard to their position nearest
# Find random opponent
var opponent = _get_random_opponent()
if not opponent:
print("[SpecialTiles] No opponent found for BURN_TILES")
return
# Get opponent's playerboard items
var board_indices = []
for i in range(opponent.playerboard.size()):
if opponent.playerboard[i] != -1:
board_indices.append(i)
if board_indices.is_empty():
return # Nothing to burn
# Pick random 1x (3x3 equivalent = ~3-4 tiles) or 2x amount
# Let's say we burn 3 to 6 tiles
var burn_count = rng.randi_range(3, 6)
board_indices.shuffle()
var tiles_burned = 0
# Get valid empty spots near opponent to dump tiles
var empty_spots = _get_empty_neighbors_recursive(opponent.current_position, 2)
empty_spots.shuffle()
for i in range(min(burn_count, board_indices.size())):
var slot_idx = board_indices[i]
var item = opponent.playerboard[slot_idx]
# Remove from opponent board
opponent.playerboard[slot_idx] = -1
# Determine where to put it
var target_pos = Vector3i.ZERO
var target_item = item
if not empty_spots.is_empty():
# Place on empty spot
var pos_2d = empty_spots.pop_back()
target_pos = Vector3i(pos_2d.x, 1, pos_2d.y)
else:
# No empty spots? "Replace it with new one" at a random nearby non-empty spot?
# Or just find ANY nearby spot and overwrite
var neighbors = enhanced_gridmap.get_neighbors(opponent.current_position, 1)
if not neighbors.is_empty():
var rand_n = neighbors[rng.randi() % neighbors.size()]
target_pos = Vector3i(rand_n.position.x, 1, rand_n.position.y)
# If we are overwriting or essentially "spawning" a new one to replace it
target_item = rng.randi_range(7, 10) # As per request "replace it with new one" if floor not empty
if target_pos != Vector3i.ZERO:
if player.is_multiplayer_authority():
var main = player.get_tree().get_root().get_node_or_null("Main")
if main:
main.rpc("sync_grid_item", target_pos.x, target_pos.y, target_pos.z, target_item)
# Sync opponent board change
main.rpc("sync_playerboard", opponent.name.to_int(), opponent.playerboard)
tiles_burned += 1
if tiles_burned > 0:
# Trigger screen shake
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: Knocked %d tiles from %s" % [tiles_burned, opponent.name])
player.rpc("display_message", "Knocked tiles from %s!" % opponent.display_name)
opponent.rpc("display_message", "%s knocked tiles out of your bag!" % player.display_name)
func _execute_spawn_tiles():
# NEW LOGIC: Spawn more in neighbor space (radius 2)
var radius = 2
var candidates = []
for x in range(-radius, radius + 1):
for y in range(-radius, radius + 1):
if x == 0 and y == 0: continue
var pos = player.current_position + Vector2i(x, y)
if enhanced_gridmap.is_position_valid(pos):
var cell = Vector3i(pos.x, 1, pos.y)
if enhanced_gridmap.get_cell_item(cell) == -1:
candidates.append(cell)
var spawn_count = rng.randi_range(3, 8) # Spawn a bunch
candidates.shuffle()
var actual_spawned = 0
for i in range(min(spawn_count, candidates.size())):
var cell = candidates[i]
var new_tile = rng.randi_range(7, 10)
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)
actual_spawned += 1
print("[SpecialTiles] SPAWN_TILES: Spawned %d tiles around %s" % [actual_spawned, player.name])
player.rpc("display_message", "Spawned tiles nearby!")
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 %s!" % opponent.display_name)
opponent.rpc("display_message", "%s froze you!" % player.display_name)
# Visual effect: Ice Blue
# Use RPC to sync visual effect to everyone (call_local handles our screen)
if opponent.has_method("sync_modulate"):
opponent.rpc("sync_modulate", Color(0.5, 0.8, 1.0))
# Standard players sync via network transform but modulation might not sync automatically unless handled.
# Let's hope basic property sync or local effect handles it enough for now,
# but ideally we should RPC a visual update method on the player.
# Checking player.gd again, there isn't a sync_modulate.
# We can just set it locally and rely on the RPCs below for syncing the EFFECT STATUS,
# but we should probably RPC the color change to be sure everyone sees it.
# Actually, since we don't have a generic sync_proeprty, we will just set it locally on the authority
# and rely on the target itself to perhaps propogate it? No, that won't work traversing network.
# We need a way to tell clients "Painter this player blue".
# The simplest safe way without modifying Player.gd extensively is to rpc a method call if available,
# or just set it on the proxy if we are the server.
# But special_tiles is running on the player who TRIGGERED it.
# If I am client A, targeting client B. I am authority of ME. B is authority of B.
# I can't set properties on B directly and expect them to sync.
# I must RPC B to freeze himself.
# The _execute_freeze_player logic calls opponent.apply_freeze or sets is_frozen.
# If opponent has authority, they will run their own logic?
# Wait, special_tiles_manager runs on the client who picked up the tile?
# "if player.is_multiplayer_authority(): rpc(...)" implies we are the authority of the player who picked it up.
# We find an opponent (which is a proxy version on our machine).
# We call methods on that proxy.
# "opponent.rpc(...)" sends a message to the authority of that opponent.
# So we should validly call an RPC on opponent to change color.
# But Player.gd doesn't have "set_modulate_rpc".
# Use "set" works locally.
# We need to add visual sync support to Player.gd or just rely on what we have.
# Given constraints, I'll add the modulate locally and maybe the opponent-side logic should handle it?
# _create_unfreeze_timer runs on OUR machine mostly? No, "await player.get_tree()..."
# If we are A, targeting B.
# We call opponent.apply_freeze(). If B has that method, good.
# If B lacks it, we set is_frozen on B's proxy and run a timer on A's machine?
# That only freezes B on A's screen if logic relies on is_frozen?
# Actually, `opponent.rpc("display_message", ...)` works.
# Let's add a `sync_visual_effect` to Player.gd if needed, or just standard property setting if supported.
# For now, I will just set it and see if I can add a dedicated RPC in Player.gd in the next step if this is insufficient,
# OR better: I'll use `opponent.rpc("sync_modulate", ...)` and add that method to Player.gd in a separate tool call.
# For this tool call, I'll update the text and set local modulate.
func _create_unfreeze_timer(target_player: Node3D, duration: float):
if not is_instance_valid(player) or not is_instance_valid(target_player):
return
await player.get_tree().create_timer(duration).timeout
if is_instance_valid(target_player):
target_player.set("is_frozen", false)
# Reset visuals
if target_player.has_method("sync_modulate"):
target_player.rpc("sync_modulate", Color.WHITE)
target_player.rpc("display_message", "Unfrozen!")
func _execute_block_floor():
# NEW LOGIC: Block 3 to 9 tiles in a line (Horizontal/Vertical/Diagonal)
# Find valid start neighbor
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():
return
var start_neighbor = valid_neighbors[rng.randi() % valid_neighbors.size()]
var start_pos = start_neighbor.position
# Random direction: H, V, D1, D2
var directions = [
Vector2i(1, 0), Vector2i(-1, 0), # Horizontal
Vector2i(0, 1), Vector2i(0, -1), # Vertical
Vector2i(1, 1), Vector2i(-1, -1), # Diagonal
Vector2i(1, -1), Vector2i(-1, 1)
]
var dir = directions[rng.randi() % directions.size()]
var count = rng.randi_range(3, 9)
var valid_block_count = 0
for i in range(count):
var target_pos_2d = start_pos + (dir * i)
# Check if valid grid position
if not enhanced_gridmap.is_position_valid(target_pos_2d):
break # Stop if we hit edge of map
var block_pos = Vector3i(target_pos_2d.x, 0, target_pos_2d.y)
var original_item = enhanced_gridmap.get_cell_item(block_pos)
# Make tile non-walkable
var blocked_item = 4
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)
blocked_tiles.append({
"position": block_pos,
"original_item": original_item,
"timer": BLOCK_DURATION
})
valid_block_count += 1
if valid_block_count > 0:
enhanced_gridmap.initialize_astar()
print("[SpecialTiles] BLOCK_FLOOR: Blocked line of %d tiles" % valid_block_count)
player.rpc("display_message", "Blocked a wall of tiles!")
func _execute_invisible_mode():
# Set invisible mode on player
# NEW LOGIC: Also enables auto-grab in _process
if player.has_method("apply_invisible_mode"):
player.apply_invisible_mode(INVISIBLE_DURATION)
else:
player.set("is_invisible", true)
player.set("original_movement_range", player.movement_range)
player.movement_range = player.movement_range + 2
invisible_timer = INVISIBLE_DURATION
print("[SpecialTiles] INVISIBLE_MODE: Activated")
player.rpc("display_message", "Invisible Mode Active!")
func _process(delta):
_update_blocked_tiles(delta)
_update_invisible_timer(delta)
func _update_invisible_timer(delta: float):
if invisible_timer > 0:
invisible_timer -= delta
if invisible_timer <= 0:
invisible_timer = 0
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 _get_empty_neighbors_recursive(center: Vector2i, radius: int) -> Array[Vector2i]:
var result: Array[Vector2i] = []
for x in range(-radius, radius + 1):
for y in range(-radius, radius + 1):
var pos = center + Vector2i(x, y)
if enhanced_gridmap.is_position_valid(pos):
if enhanced_gridmap.get_cell_item(Vector3i(pos.x, 1, pos.y)) == -1:
result.append(pos)
return result
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)
invisible_timer = 0 # Cancel timer
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
Reference in New Issue View Git Blame Copy Permalink