danchie/tekton
3
1
Fork 0
Code Issues 20 Pull Requests Actions Packages Projects 10 Releases 1 Wiki Activity

update

Browse Source
This commit is contained in:
adtpdn
2026-01-29 03:04:24 +08:00
parent 6949e20a1f
commit e66ba7542c
12 changed files with 687 additions and 549 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/managers/player_movement_manager.gd
+37 -83
View File
@@ -97,94 +97,48 @@ func try_push(target_pos: Vector2i, direction: Vector2i) -> bool:
var other_player = player.get_player_at_position(target_pos)
if not other_player:
return false # Should be occupied if we called this, but safety check
return false
# Calculate where they will be pushed to
var pushed_to_pos = target_pos + direction
# Check if pushed destination is valid
if not enhanced_gridmap.is_position_valid(pushed_to_pos):
# Blocked by world bounds -> Double Push!
other_player.rpc("apply_stagger", 1.5)
return false
# Check walkability of pushed destination
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(pushed_to_pos.x, 0, pushed_to_pos.y))
if cell_item == -1 or cell_item in enhanced_gridmap.non_walkable_items:
# Blocked by obstacle -> Double Push!
other_player.rpc("apply_stagger", 1.5)
return false
# Check if pushed destination is ALREADY occupied (Double Push / Crush)
if player.is_position_occupied(pushed_to_pos):
# Blocked by another player -> Double Push!
other_player.rpc("apply_stagger", 1.5)
return false
# Check if other player is currently moving (don't push moving players to avoid sync issues)
if other_player.is_player_moving:
# === NEW LOGIC: Only allow push if in ATTACK MODE ===
if not player.get("is_attack_mode"):
# Standard bumping effect or nothing?
# User said "Remove standard push", so we just do nothing or small shake
return false
# EXECUTE PUSH
print("Player %s PUSHING %s to %s" % [player.name, other_player.name, pushed_to_pos])
# === SUPER PUSH (Attack Mode) ===
print("Player %s SUPER PUSHING %s!" % [player.name, other_player.name])
# Force move the other player
# We use rpc to sync this change. Since we are authority, we can dictate pos.
# 1. Drop Victim's Tiles
if other_player.has_method("drop_all_tiles"):
other_player.rpc("drop_all_tiles") # Sync drop
# 1. Update their position variable immediately so our move check passes next frame?
# actually simple_move_to continues immediately.
# We need to forcefully animate/move them.
# Let's use their own movement RPC if possible, or a special push RPC.
# For simplicity, we'll assume they snap-move or use the standard path movement but faster?
# Let's use the standard movement for now to ensure consistency.
var path = [Vector2(target_pos.x, target_pos.y), Vector2(pushed_to_pos.x, pushed_to_pos.y)]
# path.pop_front() # start_movement_along_path expects full path?
# Actually start_movement_along_path usually takes [start, end] or [end]?
# Looking at simple_move_to above:
# path = [current, target]
# path.pop_front() -> path is [target]
# So it expects just the waypoints excluding start.
var push_path = [Vector2(pushed_to_pos.x, pushed_to_pos.y)]
# Call RPC on the OTHER player
other_player.rpc("start_movement_along_path", push_path, false) # false = no cam checks?
# Wait, the boolean arg is "is_local_human"?
# In player.gd call: player.rpc("start_movement_along_path", path, not (player.is_bot...))
# Update their current_position immediately so `is_position_occupied` returns false for us
# (The RPC handles the visual tween, but we need logical update)
# However, start_movement_along_path usually updates current_position at start or end?
# If we don't update it now, our `player.is_position_occupied(grid_position)` check in subsequent frames might be ok,
# but `simple_move_to` is synchronous-ish.
# Crucial: We need to make sure `player.is_position_occupied` returns false for `grid_position`
# RIGHT NOW so we can return true and move into it.
# But `is_position_occupied` checks `current_position` and `target_position`.
# So we need to update `other_player`'s state.
other_player.target_position = pushed_to_pos
other_player.is_player_moving = true # Mark them as moving so they occupy the NEW spot vs OLD spot?
# Actually is_position_occupied checks BOTH current and target.
# So if they are moving, they occupy BOTH until finished?
# See player.gd:
# if player.is_player_moving and player.target_position == pos: return true
# if player.current_position == pos: return true
# This implies a moving player blocks 2 tiles.
# If we want to move into `target_pos`, `other_player` must NOT count as occupying it.
# But they ARE at `target_pos`.
# We physically can't be at the same spot.
# So we essentially need them to VACATE `target_pos` logically.
# Hack/Fix: We manually update their `current_position` to `pushed_to_pos` immediately?
# No, that breaks visual interpolation.
# Solution: The push logic implies simultaneity or high speed.
# If we assume the push is instant-ish logic:
# We update valid logical positions. Visuals catch up.
# 2. Spawn PowerUps around Victim
# We delegate this to the attacker's SpecialTilesManager to handle the spawning authority
if player.special_tiles_manager and player.special_tiles_manager.has_method("spawn_powerups_around"):
player.special_tiles_manager.spawn_powerups_around(other_player.current_position)
# 3. Knockback / Stagger
# Push them away
var pushed_to_pos = target_pos + direction
if enhanced_gridmap.is_position_valid(pushed_to_pos) and \
enhanced_gridmap.get_cell_item(Vector3i(pushed_to_pos.x, 0, pushed_to_pos.y)) != -1 and \
not player.is_position_occupied(pushed_to_pos):
# Valid push
var push_path = [Vector2(pushed_to_pos.x, pushed_to_pos.y)]
other_player.rpc("start_movement_along_path", push_path, false)
other_player.target_position = pushed_to_pos # Logical update
else:
# Wall/Blocked -> Stagger in place
other_player.rpc("apply_stagger", 1.5)
# 4. Consume Boost
if player.powerup_manager:
player.powerup_manager.reset_boost()
# 5. Reset Attack Mode
player.is_attack_mode = false
return true