381 lines
13 KiB
GDScript
381 lines
13 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}
|
|
var invisible_timer: float = 0.0
|
|
|
|
# INVENTORY SYSTEM
|
|
# Stores count of each power-up type. Max 1 per type as per user request?
|
|
# "player can store 1 of each different power up"
|
|
var inventory = {
|
|
SpecialEffect.BURN_TILES: false, # Coin
|
|
SpecialEffect.SPAWN_TILES: false, # (Merged with Coin or deprecated? User said "coin : random between two")
|
|
# Let's map Items 7-10 to Effects
|
|
# 7=Heart=Block, 8=Diamond=Freeze, 9=Star=Invisible, 10=Coin=Burn/Spawn
|
|
SpecialEffect.BLOCK_FLOOR: false,
|
|
SpecialEffect.FREEZE_PLAYER: false,
|
|
SpecialEffect.INVISIBLE_MODE: false
|
|
}
|
|
|
|
# Signal for UI
|
|
signal inventory_updated(inventory_data: Dictionary)
|
|
|
|
func initialize(p_player: Node3D, p_gridmap: Node):
|
|
player = p_player
|
|
enhanced_gridmap = p_gridmap
|
|
rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
# =============================================================================
|
|
# Helper: Item ID to Effect Enum
|
|
# =============================================================================
|
|
func get_effect_from_item(item_id: int) -> int:
|
|
match item_id:
|
|
7: return SpecialEffect.BLOCK_FLOOR # Heart
|
|
8: return SpecialEffect.FREEZE_PLAYER # Diamond
|
|
9: return SpecialEffect.INVISIBLE_MODE # Star
|
|
10: return SpecialEffect.BURN_TILES # Coin (Handles Burn or Spawn)
|
|
_: return -1
|
|
|
|
func add_powerup_from_item(item_id: int):
|
|
var effect = get_effect_from_item(item_id)
|
|
if effect != -1:
|
|
inventory[effect] = true
|
|
emit_signal("inventory_updated", inventory)
|
|
print("Player %s picked up powerup for effect %s" % [player.name, SpecialEffect.keys()[effect]])
|
|
|
|
if player.is_multiplayer_authority():
|
|
rpc("sync_inventory_add", effect)
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func sync_inventory_add(effect: int):
|
|
inventory[effect] = true
|
|
emit_signal("inventory_updated", inventory)
|
|
|
|
func remove_powerup(effect: int):
|
|
inventory[effect] = false
|
|
emit_signal("inventory_updated", inventory)
|
|
if player.is_multiplayer_authority():
|
|
rpc("sync_inventory_remove", effect)
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func sync_inventory_remove(effect: int):
|
|
inventory[effect] = false
|
|
emit_signal("inventory_updated", inventory)
|
|
|
|
# =============================================================================
|
|
# Activate Effect (Explicit Target)
|
|
# =============================================================================
|
|
|
|
func activate_effect(effect: int, target_player: Node3D = null):
|
|
# Validation
|
|
if not inventory.get(effect, false):
|
|
return # Start/Client mismatch
|
|
|
|
# Consume
|
|
remove_powerup(effect)
|
|
|
|
print("[SpecialTiles] Player %s activated %s on %s" % [player.name, SpecialEffect.keys()[effect], target_player.name if target_player else "Self"])
|
|
|
|
match effect:
|
|
SpecialEffect.BURN_TILES:
|
|
# Coin: Random between Burn or Spawn
|
|
# "coin : random between two... make it not use directly" -> When activated, it does one of them.
|
|
if rng.randf() < 0.5:
|
|
_execute_burn_tiles(target_player)
|
|
else:
|
|
# Spawn tiles around SELF (as per user request "around activating player")
|
|
_execute_spawn_tiles(player)
|
|
|
|
SpecialEffect.BLOCK_FLOOR:
|
|
if target_player:
|
|
_execute_block_floor(target_player)
|
|
|
|
SpecialEffect.FREEZE_PLAYER:
|
|
if target_player:
|
|
_execute_freeze_player(target_player)
|
|
|
|
SpecialEffect.INVISIBLE_MODE:
|
|
# Always self
|
|
_execute_invisible_mode(player)
|
|
|
|
# Play generic cast animation or sound?
|
|
if player.is_multiplayer_authority():
|
|
player.rpc("trigger_screen_shake", "light")
|
|
|
|
|
|
# =============================================================================
|
|
# 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(_get_random_opponent())
|
|
SpecialEffect.SPAWN_TILES:
|
|
_execute_spawn_tiles(player)
|
|
SpecialEffect.FREEZE_PLAYER:
|
|
_execute_freeze_player(_get_random_opponent())
|
|
SpecialEffect.BLOCK_FLOOR:
|
|
_execute_block_floor(player)
|
|
SpecialEffect.INVISIBLE_MODE:
|
|
_execute_invisible_mode(player)
|
|
|
|
# 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(target: Node3D):
|
|
if not target: return
|
|
|
|
# Knock tiles from target's board
|
|
var board_indices = []
|
|
for i in range(target.playerboard.size()):
|
|
if target.playerboard[i] != -1:
|
|
board_indices.append(i)
|
|
|
|
if board_indices.is_empty():
|
|
return
|
|
|
|
var burn_count = rng.randi_range(3, 6)
|
|
board_indices.shuffle()
|
|
|
|
# Drop logic similar to burn but we just destroy them or scatter?
|
|
# "BURN_TILES, # Remove 3x3 pattern tiles" -> User request says Remove pattern.
|
|
# Original code did burn.
|
|
# Let's just remove them.
|
|
|
|
for i in range(min(burn_count, board_indices.size())):
|
|
target.playerboard[board_indices[i]] = -1
|
|
|
|
if player.is_multiplayer_authority():
|
|
# Sync the change on the target
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_playerboard", target.name.to_int(), target.playerboard)
|
|
|
|
target.rpc("display_message", "Burned by %s!" % player.display_name, 3)
|
|
|
|
|
|
func _execute_spawn_tiles(target: Node3D):
|
|
# Spawn tiles around TARGET (usually Self for Coin)
|
|
spawn_powerups_around(target.current_position, false) # False = normal tiles? User says "Spawn 3x3 pattern tiles"
|
|
# Okay "SPAWN_TILES" usually means useful numbered tiles.
|
|
# But "spawn / replace your nearby tiles into power up" is for Headbutt.
|
|
# For Coin->Spawn_Tiles: "Spawn 3x3 pattern tiles around activating player ( self )".
|
|
# So random number tiles (7-10 are powerups, 1-6 are normal? No, 7-10 are patterns in this game).
|
|
# "Spawn 3x3 pattern tiles" -> Tiles with ID 7,8,9,10 are the goal tiles.
|
|
|
|
target.rpc("display_message", "Tiles Spawned!", 2)
|
|
|
|
func _execute_freeze_player(target: Node3D):
|
|
if not target:
|
|
print("[SpecialTiles] No opponent found for FREEZE_PLAYER")
|
|
return
|
|
|
|
if target.has_method("apply_stagger"): # Stagger = Freeze roughly
|
|
target.rpc("apply_stagger", FREEZE_DURATION)
|
|
else:
|
|
target.set("is_frozen", true)
|
|
_create_unfreeze_timer(target, FREEZE_DURATION)
|
|
|
|
target.rpc("display_message", "Frozen by %s!" % player.display_name, 3)
|
|
|
|
func _execute_block_floor(target: Node3D):
|
|
# Make nearby tile non-walkable for 9 seconds
|
|
# Target the floor UNDER or NEAR the target?
|
|
# "block ( other player ) spawn BLOCK_FLOOR Make nearby tile non-walkable"
|
|
# Let's block the tile they are standing on + neighbors?
|
|
var center = target.current_position
|
|
var neighbors = enhanced_gridmap.get_neighbors(center, 1) # Include diagonals
|
|
neighbors.append({"position": center}) # Add center
|
|
|
|
for n in neighbors:
|
|
var pos = n.position
|
|
var block_pos = Vector3i(pos.x, 0, pos.y)
|
|
|
|
# Block it
|
|
if player.is_multiplayer_authority():
|
|
var main = player.get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
# 4 = Blocked Tile ID usually
|
|
main.rpc("sync_grid_item", block_pos.x, block_pos.y, block_pos.z, 4)
|
|
|
|
var original_item = enhanced_gridmap.get_cell_item(block_pos)
|
|
blocked_tiles.append({
|
|
"position": block_pos,
|
|
"original_item": original_item if original_item != 4 else 0, # Restore to 0 (floor) if confused
|
|
"timer": BLOCK_DURATION
|
|
})
|
|
|
|
target.rpc("display_message", "Floor Blocked!", 3)
|
|
|
|
func _execute_invisible_mode(target: Node3D):
|
|
target.is_invisible = true
|
|
# Auto-disable after duration handled in Player._process or here?
|
|
# SpecialTilesManager seems to handle effect timers.
|
|
invisible_timer = INVISIBLE_DURATION
|
|
target.rpc("display_message", "Invisible!", 2)
|
|
|
|
|
|
# =============================================================================
|
|
# Helper: Spawn Powerups (For Super Push)
|
|
# =============================================================================
|
|
|
|
func spawn_powerups_around(center: Vector2i, force_powerups: bool = true):
|
|
# "spawn / replace your nearby tiles into power up ( special tiles )"
|
|
# PowerUp Tiles are 7, 8, 9, 10 (Heart, Diamond, Star, Coin)
|
|
|
|
var radius = 2
|
|
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):
|
|
# Random chance
|
|
if rng.randf() > 0.4: continue
|
|
|
|
var item_id = rng.randi_range(7, 10) # 7-10 are the special tiles
|
|
var cell = Vector3i(pos.x, 1, pos.y)
|
|
|
|
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, item_id)
|
|
|
|
|
|
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.is_invisible = false
|
|
player.rpc("display_message", "Invisibility 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
|
|
|
|
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)
|
|
# Reset visuals
|
|
if target_player.has_method("sync_modulate"):
|
|
target_player.rpc("sync_modulate", Color.WHITE)
|
|
target_player.rpc("display_message", "Unfrozen!")
|