feat: add player core, movement, and playerboard managers, special tile effects system, and lobby scene.
This commit is contained in:
@@ -0,0 +1,294 @@
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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
|
||||
Reference in New Issue
Block a user