830 lines
34 KiB
GDScript
830 lines
34 KiB
GDScript
extends CharacterBody2D
|
|
|
|
# Loot Item - Coins and food items that drop from enemies
|
|
|
|
enum LootType {
|
|
COIN,
|
|
APPLE,
|
|
BANANA,
|
|
CHERRY,
|
|
KEY,
|
|
ITEM # Item instance (equipment, consumables, etc.)
|
|
}
|
|
|
|
@export var loot_type: LootType = LootType.COIN
|
|
|
|
# Z-axis physics (like boxes and players)
|
|
var position_z: float = 0.0
|
|
var velocity_z: float = 0.0
|
|
var acceleration_z: float = 0.0
|
|
var is_airborne: bool = true
|
|
var velocity_set_by_spawner: bool = false # Track if velocity was set externally
|
|
|
|
# Bounce physics
|
|
var bounce_restitution: float = 0.6 # How much bounce energy is retained (0-1) - matches old code
|
|
var min_bounce_velocity: float = 40.0 # Minimum velocity needed to bounce
|
|
var friction: float = 8.0 # Friction when on ground (lower = more gradual slowdown, matches old code)
|
|
var bounce_timer: float = 0.0 # Prevent rapid bounce sounds
|
|
|
|
# Multiplayer sync and prediction
|
|
var sync_timer: float = 0.0 # Timer for periodic position/velocity sync
|
|
var sync_interval: float = 0.05 # Sync every 0.05 seconds (20 times per second) for smoother sync
|
|
var last_sync_time: float = 0.0 # Track last server sync time for reconciliation
|
|
var server_position: Vector2 = Vector2.ZERO # Last server-authoritative position
|
|
var server_velocity: Vector2 = Vector2.ZERO # Last server-authoritative velocity
|
|
var server_position_z: float = 0.0 # Last server-authoritative Z position
|
|
var server_velocity_z: float = 0.0 # Last server-authoritative Z velocity
|
|
var prediction_error_threshold: float = 10.0 # Distance threshold before correcting (pixels)
|
|
var correction_smoothing: float = 0.3 # Lerp factor for smooth correction (0-1, lower = smoother)
|
|
|
|
# Loot properties
|
|
var coin_value: int = 1
|
|
var heal_amount: float = 20.0
|
|
var collected: bool = false
|
|
var item: Item = null # Item instance (for LootType.ITEM)
|
|
|
|
@onready var sprite = $Sprite2D
|
|
@onready var shadow = $Shadow
|
|
@onready var pickup_area = $PickupArea
|
|
@onready var collision_shape = $CollisionShape2D
|
|
@onready var sfx_coin_bounce = $SfxCoinBounce
|
|
@onready var sfx_coin_collect = $SfxCoinCollect
|
|
@onready var sfx_loot_collect = $SfxLootCollect
|
|
@onready var sfx_potion_collect = $SfxPotionCollect
|
|
@onready var sfx_banana_collect = $SfxBananaCollect
|
|
@onready var sfx_key_collect = $SfxKeyCollect
|
|
|
|
# Quantity badge for items with quantity > 1
|
|
var quantity_badge: Label = null
|
|
|
|
func _ready():
|
|
add_to_group("loot")
|
|
|
|
# Setup shadow
|
|
if shadow:
|
|
shadow.modulate = Color(0, 0, 0, 0.5)
|
|
shadow.z_index = -1
|
|
|
|
# Setup pickup area
|
|
if pickup_area:
|
|
pickup_area.body_entered.connect(_on_pickup_area_body_entered)
|
|
# Set collision mask to detect players (layer 1)
|
|
pickup_area.collision_mask = 1
|
|
|
|
# Top-down physics
|
|
motion_mode = MOTION_MODE_FLOATING
|
|
|
|
# Initial velocity is set by spawner (server) or synced via RPC (clients)
|
|
# If not set externally, use defaults (shouldn't happen in normal flow)
|
|
if not velocity_set_by_spawner:
|
|
velocity_z = randf_range(80.0, 120.0)
|
|
var random_angle = randf() * PI * 2
|
|
var random_force = randf_range(50.0, 100.0)
|
|
velocity = Vector2(cos(random_angle), sin(random_angle)) * random_force
|
|
is_airborne = true
|
|
|
|
# Setup sprite based on loot type (call after all properties are set)
|
|
call_deferred("_setup_sprite")
|
|
|
|
# Setup collision shape based on loot type
|
|
call_deferred("_setup_collision_shape")
|
|
|
|
# Adjust bounce properties based on loot type
|
|
if loot_type == LootType.COIN:
|
|
bounce_restitution = 0.6 # Matches old code - more bouncy
|
|
min_bounce_velocity = 40.0
|
|
friction = 8.0 # Lower friction for coins - more gradual slowdown
|
|
else:
|
|
bounce_restitution = 0.3 # Lower bounce for food items
|
|
min_bounce_velocity = 60.0
|
|
friction = 12.0 # Slightly higher friction for food items
|
|
|
|
func _setup_sprite():
|
|
if not sprite:
|
|
return
|
|
|
|
match loot_type:
|
|
LootType.COIN:
|
|
# Load coin texture
|
|
var coin_texture = load("res://assets/gfx/pickups/gold_coin.png")
|
|
if coin_texture and sprite:
|
|
sprite.texture = coin_texture
|
|
sprite.hframes = 6
|
|
sprite.vframes = 1
|
|
sprite.frame = 0
|
|
print("Coin sprite setup: texture=", coin_texture != null, " hframes=", sprite.hframes, " vframes=", sprite.vframes, " frame=", sprite.frame)
|
|
else:
|
|
print("ERROR: Coin texture or sprite is null! texture=", coin_texture, " sprite=", sprite)
|
|
LootType.APPLE:
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
if items_texture:
|
|
sprite.texture = items_texture
|
|
sprite.hframes = 20
|
|
sprite.vframes = 14
|
|
sprite.frame = (8 * 20) + 10
|
|
LootType.BANANA:
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
if items_texture:
|
|
sprite.texture = items_texture
|
|
sprite.hframes = 20
|
|
sprite.vframes = 14
|
|
sprite.frame = (8 * 20) + 11
|
|
LootType.CHERRY:
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
if items_texture:
|
|
sprite.texture = items_texture
|
|
sprite.hframes = 20
|
|
sprite.vframes = 14
|
|
sprite.frame = (8 * 20) + 12
|
|
LootType.KEY:
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
if items_texture:
|
|
sprite.texture = items_texture
|
|
sprite.hframes = 20
|
|
sprite.vframes = 14
|
|
sprite.frame = (13 * 20) + 10
|
|
LootType.ITEM:
|
|
# Item instance - use item's spritePath and spriteFrame
|
|
if item and item.spritePath != "":
|
|
var items_texture = load(item.spritePath)
|
|
if items_texture:
|
|
sprite.texture = items_texture
|
|
sprite.hframes = item.spriteFrames.x if item.spriteFrames.x > 0 else 20
|
|
sprite.vframes = item.spriteFrames.y if item.spriteFrames.y > 0 else 14
|
|
sprite.frame = item.spriteFrame
|
|
ItemDatabase.apply_item_colors_to_sprite(sprite, item)
|
|
print("Loot: Set up item sprite for ", item.item_name, " frame=", sprite.frame)
|
|
|
|
# Add quantity badge if quantity > 1
|
|
if item.quantity > 1:
|
|
_create_quantity_badge(item.quantity)
|
|
else:
|
|
print("Loot: ERROR - Could not load texture from spritePath: ", item.spritePath)
|
|
else:
|
|
print("Loot: ERROR - Item loot has no item instance or spritePath! item=", item)
|
|
|
|
func _setup_collision_shape():
|
|
if not collision_shape:
|
|
# Try to find existing collision shape
|
|
collision_shape = get_node_or_null("CollisionShape2D")
|
|
if not collision_shape:
|
|
# Create collision shape if it doesn't exist
|
|
collision_shape = CollisionShape2D.new()
|
|
add_child(collision_shape)
|
|
|
|
# Get or create circle shape
|
|
var circle_shape: CircleShape2D = null
|
|
if collision_shape.shape and collision_shape.shape is CircleShape2D:
|
|
circle_shape = collision_shape.shape as CircleShape2D
|
|
else:
|
|
circle_shape = CircleShape2D.new()
|
|
|
|
# Set collision size based on loot type
|
|
if loot_type == LootType.COIN:
|
|
circle_shape.radius = 3.0 # 6x6 pixels (diameter)
|
|
else:
|
|
circle_shape.radius = 7.0 # 14x14 pixels (diameter)
|
|
|
|
collision_shape.shape = circle_shape
|
|
|
|
func _create_quantity_badge(quantity: int):
|
|
# Create a label to show the quantity
|
|
quantity_badge = Label.new()
|
|
quantity_badge.text = str(quantity)
|
|
quantity_badge.add_theme_font_size_override("font_size", 8)
|
|
quantity_badge.add_theme_color_override("font_color", Color.WHITE)
|
|
quantity_badge.add_theme_color_override("font_outline_color", Color.BLACK)
|
|
quantity_badge.add_theme_constant_override("outline_size", 2)
|
|
quantity_badge.z_index = 100 # Above the sprite
|
|
quantity_badge.position = Vector2(6, -8) # Bottom right of sprite
|
|
add_child(quantity_badge)
|
|
|
|
func _physics_process(delta):
|
|
# Stop all physics processing if collected
|
|
if collected:
|
|
return
|
|
|
|
var is_client = multiplayer.has_multiplayer_peer() and not is_multiplayer_authority()
|
|
var is_server = not multiplayer.has_multiplayer_peer() or is_multiplayer_authority()
|
|
|
|
# Server (authority): Run physics normally
|
|
if is_server:
|
|
# Update bounce timer
|
|
if bounce_timer > 0.0:
|
|
bounce_timer -= delta
|
|
if bounce_timer < 0:
|
|
bounce_timer = 0.0
|
|
|
|
# Update Z-axis physics
|
|
if is_airborne:
|
|
# Apply gravity to Z-axis (matches old code)
|
|
acceleration_z = -300.0 # Gravity
|
|
velocity_z += acceleration_z * delta
|
|
position_z += velocity_z * delta
|
|
|
|
# Ground collision and bounce (matches old code - simpler, no aggressive damping)
|
|
if position_z <= 0.0:
|
|
position_z = 0.0
|
|
|
|
# Apply friction ONLY when on ground (matches old code behavior)
|
|
velocity = velocity.lerp(Vector2.ZERO, 1.0 - exp(-friction * delta))
|
|
|
|
# Check if we should bounce (simpler logic matching old code)
|
|
if not collected and abs(velocity_z) > min_bounce_velocity:
|
|
# Play bounce sound for coins (matches old code volume formula)
|
|
if loot_type == LootType.COIN and bounce_timer == 0.0 and velocity_z < 0.0:
|
|
if sfx_coin_bounce:
|
|
# Old code formula: -1 + (-10 - (velocityZ * 0.1))
|
|
# Adjusted for negative velocity_z
|
|
sfx_coin_bounce.volume_db = -1.0 + (-10.0 - (abs(velocity_z) * 0.1))
|
|
sfx_coin_bounce.play()
|
|
bounce_timer = 0.08 # Matches old code timing
|
|
|
|
# Simple bounce (matches old code)
|
|
velocity_z = - velocity_z * bounce_restitution
|
|
is_airborne = true # Still bouncing
|
|
else:
|
|
# Velocity too small or collected - stop bouncing
|
|
velocity_z = 0.0
|
|
is_airborne = false
|
|
else:
|
|
is_airborne = false
|
|
# Ensure velocity_z is zero when on ground
|
|
velocity_z = 0.0
|
|
# Apply friction when on ground (matches old code)
|
|
velocity = velocity.lerp(Vector2.ZERO, 1.0 - exp(-friction * delta))
|
|
|
|
# Move and check for collisions
|
|
move_and_slide()
|
|
|
|
# Check for wall collisions (skip if collected to prevent bounce sounds)
|
|
# Matches old code behavior - simpler wall bounce without aggressive velocity reduction
|
|
if not collected:
|
|
for i in get_slide_collision_count():
|
|
var collision = get_slide_collision(i)
|
|
if collision:
|
|
var collider = collision.get_collider()
|
|
# Only bounce off walls, not players (players are detected via PickupArea)
|
|
if collider and not collider.is_in_group("player"):
|
|
# Check if velocity is too small before bouncing (prevent infinite micro-bounces)
|
|
var velocity_magnitude = velocity.length()
|
|
if velocity_magnitude < 15.0: # If velocity is very small, stop bouncing
|
|
velocity = Vector2.ZERO
|
|
continue # Skip bounce and sound
|
|
|
|
# Bounce off walls (matches old code - no aggressive velocity reduction)
|
|
var normal = collision.get_normal()
|
|
velocity = velocity.bounce(normal) # Old code didn't reduce velocity here
|
|
|
|
# Play bounce sound for coins hitting walls (matches old code)
|
|
if loot_type == LootType.COIN and bounce_timer == 0.0:
|
|
if sfx_coin_bounce:
|
|
sfx_coin_bounce.volume_db = -5.0
|
|
sfx_coin_bounce.play()
|
|
bounce_timer = 0.08 # Matches old code timing
|
|
|
|
# Update visual position based on Z
|
|
_update_visuals()
|
|
|
|
# Animate coin rotation (always animate, even when not airborne)
|
|
if loot_type == LootType.COIN:
|
|
_animate_coin(delta)
|
|
|
|
# Server: Periodically sync position/velocity to clients (sync more frequently when airborne)
|
|
sync_timer += delta
|
|
# Sync more frequently when airborne (bouncing), less when settled
|
|
var current_interval = sync_interval if is_airborne else sync_interval * 2.0
|
|
if sync_timer >= current_interval:
|
|
sync_timer = 0.0
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_physics"):
|
|
var loot_id = get_meta("loot_id") if has_meta("loot_id") else -1
|
|
if loot_id >= 0:
|
|
game_world._rpc_to_ready_peers("_sync_loot_physics", [loot_id, global_position, velocity, position_z, velocity_z])
|
|
|
|
# Client (prediction): Run physics locally for smooth movement, then reconcile with server
|
|
elif is_client:
|
|
# Run physics locally (client-side prediction) - same logic as server
|
|
# Update bounce timer
|
|
if bounce_timer > 0.0:
|
|
bounce_timer -= delta
|
|
if bounce_timer < 0:
|
|
bounce_timer = 0.0
|
|
|
|
# Update Z-axis physics
|
|
if is_airborne:
|
|
# Apply gravity to Z-axis (matches server)
|
|
acceleration_z = -300.0
|
|
velocity_z += acceleration_z * delta
|
|
position_z += velocity_z * delta
|
|
|
|
# Ground collision and bounce (matches server logic)
|
|
if position_z <= 0.0:
|
|
position_z = 0.0
|
|
velocity = velocity.lerp(Vector2.ZERO, 1.0 - exp(-friction * delta))
|
|
|
|
if not collected and abs(velocity_z) > min_bounce_velocity:
|
|
# Play bounce sound for coins
|
|
if loot_type == LootType.COIN and bounce_timer == 0.0 and velocity_z < 0.0:
|
|
if sfx_coin_bounce:
|
|
sfx_coin_bounce.volume_db = -1.0 + (-10.0 - (abs(velocity_z) * 0.1))
|
|
sfx_coin_bounce.play()
|
|
bounce_timer = 0.08
|
|
velocity_z = - velocity_z * bounce_restitution
|
|
is_airborne = true
|
|
else:
|
|
velocity_z = 0.0
|
|
is_airborne = false
|
|
else:
|
|
is_airborne = false
|
|
velocity_z = 0.0
|
|
velocity = velocity.lerp(Vector2.ZERO, 1.0 - exp(-friction * delta))
|
|
|
|
# Move and check for collisions
|
|
move_and_slide()
|
|
|
|
# Check for wall collisions
|
|
if not collected:
|
|
for i in get_slide_collision_count():
|
|
var collision = get_slide_collision(i)
|
|
if collision:
|
|
var collider = collision.get_collider()
|
|
if collider and not collider.is_in_group("player"):
|
|
var velocity_magnitude = velocity.length()
|
|
if velocity_magnitude < 15.0:
|
|
velocity = Vector2.ZERO
|
|
continue
|
|
var normal = collision.get_normal()
|
|
velocity = velocity.bounce(normal)
|
|
if loot_type == LootType.COIN and bounce_timer == 0.0:
|
|
if sfx_coin_bounce:
|
|
sfx_coin_bounce.volume_db = -5.0
|
|
sfx_coin_bounce.play()
|
|
bounce_timer = 0.08
|
|
|
|
# Update visuals
|
|
_update_visuals()
|
|
|
|
# Animate coin rotation
|
|
if loot_type == LootType.COIN:
|
|
_animate_coin(delta)
|
|
|
|
# Reconcile with server state if available (called from game_world._sync_loot_physics)
|
|
# Server state is stored in server_position, server_velocity, etc. variables
|
|
# Reconciliation happens in game_world._reconcile_loot_state()
|
|
|
|
func _update_z_physics(delta):
|
|
position_z += velocity_z * delta
|
|
|
|
func _update_visuals():
|
|
# Update sprite position based on Z
|
|
if sprite:
|
|
sprite.position.y = - position_z * 0.5
|
|
|
|
# Update shadow scale and opacity based on Z
|
|
if shadow:
|
|
var shadow_scale = 1.0 - (position_z / 50.0) * 0.5
|
|
shadow.scale = Vector2.ONE * max(0.3, shadow_scale)
|
|
shadow.modulate.a = 0.5 - (position_z / 50.0) * 0.2
|
|
|
|
var coin_anim_time: float = 0.0
|
|
func _animate_coin(delta):
|
|
# Rotate coin animation
|
|
if sprite and loot_type == LootType.COIN:
|
|
# Make sure sprite is set up correctly (in case _setup_sprite hasn't run yet)
|
|
if sprite.hframes < 6 or sprite.texture == null:
|
|
_setup_sprite()
|
|
# Animate coin rotation
|
|
coin_anim_time += delta * 10.0 # Animation speed
|
|
var frame = int(coin_anim_time) % 6
|
|
sprite.frame = frame
|
|
|
|
func _on_pickup_area_body_entered(body):
|
|
if body and body.is_in_group("player") and not body.is_dead:
|
|
# Check if this item was dropped by this player recently (5 second cooldown)
|
|
if has_meta("dropped_by_peer_id") and has_meta("drop_time"):
|
|
var dropped_by_peer_id = get_meta("dropped_by_peer_id")
|
|
var drop_time = get_meta("drop_time")
|
|
var current_time = Time.get_ticks_msec()
|
|
var time_since_drop = (current_time - drop_time) / 1000.0 # Convert to seconds
|
|
|
|
# Check if this player dropped the item and cooldown hasn't expired
|
|
if body.has_method("get_multiplayer_authority"):
|
|
var player_peer_id = body.get_multiplayer_authority()
|
|
if player_peer_id == dropped_by_peer_id and time_since_drop < 5.0:
|
|
# Player can't pick up their own dropped item for 5 seconds
|
|
print("Loot: Player ", body.name, " cannot pick up item they dropped (", time_since_drop, "s ago, need 5s cooldown)")
|
|
return
|
|
|
|
print("Loot: Pickup area entered by player: ", body.name, " is_local: ", body.is_local_player if "is_local_player" in body else "unknown", " is_server: ", multiplayer.is_server())
|
|
_pickup(body)
|
|
|
|
func _pickup(player: Node):
|
|
# Prevent multiple pickups
|
|
if collected:
|
|
print("Loot: Already collected, ignoring pickup")
|
|
return
|
|
|
|
var player_auth_str = "N/A"
|
|
if "get_multiplayer_authority" in player:
|
|
player_auth_str = str(player.get_multiplayer_authority())
|
|
print("Loot: _pickup called by player: ", player.name, " is_server: ", multiplayer.is_server(), " has_peer: ", multiplayer.has_multiplayer_peer(), " player_authority: ", player_auth_str)
|
|
|
|
# In multiplayer, only process on server or if player has authority
|
|
# If client player picks it up, send RPC to server
|
|
if multiplayer.has_multiplayer_peer():
|
|
if not multiplayer.is_server():
|
|
# Client: send pickup request to server
|
|
if player.is_multiplayer_authority():
|
|
# This is the local player, send request to server
|
|
var player_peer_id = player.get_multiplayer_authority()
|
|
print("Loot: Client sending pickup request to server for player peer_id: ", player_peer_id)
|
|
# Route through game_world to avoid node path issues
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
var loot_id = get_meta("loot_id") if has_meta("loot_id") else -1
|
|
if game_world and game_world.has_method("_request_loot_pickup"):
|
|
game_world._request_loot_pickup.rpc_id(1, loot_id, global_position, player_peer_id)
|
|
else:
|
|
# Fallback: try direct RPC
|
|
rpc_id(1, "_request_pickup", player_peer_id)
|
|
else:
|
|
print("Loot: Client player does not have authority, cannot pickup")
|
|
return
|
|
else:
|
|
# Server: If player doesn't have authority, this is a client player
|
|
# The client will send _request_pickup RPC, so we should ignore this Area2D signal
|
|
# to avoid duplicate processing and errors
|
|
if not player.is_multiplayer_authority():
|
|
# Client player - they will send RPC, so ignore this signal completely
|
|
# This prevents race conditions where server's Area2D fires before client's RPC arrives
|
|
# Don't log as error since this is expected behavior
|
|
return
|
|
|
|
# Process the pickup (common code for both server and single-player)
|
|
_process_pickup_on_server(player)
|
|
|
|
func _process_pickup_on_server(player: Node):
|
|
# Internal function to process pickup on server (called from _request_pickup RPC)
|
|
# This skips the authority check since we've already validated the request
|
|
# Mark as collected immediately to prevent duplicate pickups
|
|
# (Note: This may already be set by _request_pickup, but set it here too for safety)
|
|
if not collected:
|
|
collected = true
|
|
|
|
# Disable pickup area immediately to prevent further collisions
|
|
# Use set_deferred() because we're in a signal callback
|
|
if pickup_area:
|
|
pickup_area.set_deferred("monitoring", false)
|
|
pickup_area.set_deferred("monitorable", false)
|
|
|
|
# Sync removal to all clients FIRST (before processing pickup)
|
|
# This ensures clients remove the loot even if host processes it
|
|
# Use game_world to route removal sync instead of direct RPC to avoid node path issues
|
|
if multiplayer.has_multiplayer_peer() and is_inside_tree():
|
|
var loot_id = get_meta("loot_id") if has_meta("loot_id") else -1
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_remove"):
|
|
print("Loot: Server syncing removal of loot id=", loot_id, " at ", global_position)
|
|
game_world._rpc_to_ready_peers("_sync_loot_remove", [loot_id, global_position])
|
|
else:
|
|
# If GameWorld isn't ready, skip removal sync to avoid node path RPC errors
|
|
print("Loot: GameWorld not ready, skipping removal sync for loot id=", loot_id)
|
|
|
|
match loot_type:
|
|
LootType.COIN:
|
|
if sfx_coin_collect:
|
|
sfx_coin_collect.play()
|
|
# Give player coin
|
|
if player.has_method("add_coins"):
|
|
player.add_coins(coin_value)
|
|
# Show floating text with item graphic and text
|
|
var coin_texture = load("res://assets/gfx/pickups/gold_coin.png")
|
|
_show_floating_text(player, "+" + str(coin_value) + " COIN", Color(1.0, 0.84, 0.0), 0.5, 0.5, coin_texture, 6, 1, 0)
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, "+" + str(coin_value) + " COIN", Color(1.0, 0.84, 0.0), 0, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_coin_collect and sfx_coin_collect.playing:
|
|
await sfx_coin_collect.finished
|
|
queue_free()
|
|
LootType.APPLE:
|
|
if sfx_potion_collect:
|
|
sfx_potion_collect.play()
|
|
# Heal player
|
|
var actual_heal = 0.0
|
|
if player.has_method("heal"):
|
|
actual_heal = heal_amount
|
|
player.heal(heal_amount)
|
|
# Show floating text with item graphic and heal amount
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
_show_floating_text(player, "+" + str(int(actual_heal)) + " HP", Color.GREEN, 0.5, 0.5, items_texture, 20, 14, (8 * 20) + 10)
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, "+" + str(int(actual_heal)) + " HP", Color.GREEN, (8 * 20) + 10, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_potion_collect and sfx_potion_collect.playing:
|
|
await sfx_potion_collect.finished
|
|
queue_free()
|
|
LootType.BANANA:
|
|
if sfx_banana_collect:
|
|
sfx_banana_collect.play()
|
|
# Heal player
|
|
var actual_heal = 0.0
|
|
if player.has_method("heal"):
|
|
actual_heal = heal_amount
|
|
player.heal(heal_amount)
|
|
# Show floating text with item graphic and heal amount
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
_show_floating_text(player, "+" + str(int(actual_heal)) + " HP", Color.GREEN, 0.5, 0.5, items_texture, 20, 14, (8 * 20) + 11)
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, "+" + str(int(actual_heal)) + " HP", Color.GREEN, (8 * 20) + 11, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_banana_collect and sfx_banana_collect.playing:
|
|
await sfx_banana_collect.finished
|
|
queue_free()
|
|
LootType.CHERRY:
|
|
if sfx_banana_collect:
|
|
sfx_banana_collect.play()
|
|
# Heal player
|
|
var actual_heal = 0.0
|
|
if player.has_method("heal"):
|
|
actual_heal = heal_amount
|
|
player.heal(heal_amount)
|
|
# Show floating text with item graphic and heal amount
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
_show_floating_text(player, "+" + str(int(actual_heal)) + " HP", Color.GREEN, 0.5, 0.5, items_texture, 20, 14, (8 * 20) + 12)
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, "+" + str(int(actual_heal)) + " HP", Color.GREEN, (8 * 20) + 12, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_banana_collect and sfx_banana_collect.playing:
|
|
await sfx_banana_collect.finished
|
|
queue_free()
|
|
LootType.KEY:
|
|
if sfx_key_collect:
|
|
sfx_key_collect.play()
|
|
# Give player key in inventory
|
|
if player.has_method("add_key"):
|
|
player.add_key(1)
|
|
# Show floating text with item graphic and text
|
|
var items_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
_show_floating_text(player, "+1 KEY", Color.YELLOW, 0.5, 0.5, items_texture, 20, 14, (13 * 20) + 10)
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, "+1 KEY", Color.YELLOW, (13 * 20) + 10, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_key_collect and sfx_key_collect.playing:
|
|
await $SfxKeyCollect.finished
|
|
queue_free()
|
|
LootType.ITEM:
|
|
# Item instance pickup
|
|
if not item:
|
|
print("Loot: ERROR - Item loot has no item instance!")
|
|
queue_free()
|
|
return
|
|
|
|
if sfx_loot_collect:
|
|
sfx_loot_collect.play()
|
|
|
|
# Handle item pickup based on type
|
|
var was_encumbered = player.character_stats.is_over_encumbered() if player.character_stats else false
|
|
if item.item_type == Item.ItemType.Equippable:
|
|
# Equippable item - add to inventory
|
|
if player.character_stats:
|
|
player.character_stats.add_item(item)
|
|
print(name, " picked up item: ", item.item_name, " (added to inventory)")
|
|
elif item.item_type == Item.ItemType.Restoration:
|
|
# Consumable item - add to inventory (use with F key in inventory)
|
|
if player.character_stats:
|
|
player.character_stats.add_item(item)
|
|
print(name, " picked up item: ", item.item_name, " (added to inventory)")
|
|
if player.character_stats and not was_encumbered and player.character_stats.is_over_encumbered():
|
|
if player.has_method("show_floating_status"):
|
|
player.show_floating_status("Encumbered!", Color(1.0, 0.5, 0.2))
|
|
|
|
# Sync inventory+equipment to joiner (server added to their copy; joiner's client must apply)
|
|
if multiplayer.has_multiplayer_peer() and multiplayer.is_server():
|
|
var owner_id = player.get_multiplayer_authority()
|
|
if owner_id != 1 and owner_id != multiplayer.get_unique_id():
|
|
var inv_data: Array = []
|
|
for inv_item in player.character_stats.inventory:
|
|
inv_data.append(inv_item.save() if inv_item else null)
|
|
var equip_data: Dictionary = {}
|
|
for slot_name in player.character_stats.equipment.keys():
|
|
var eq = player.character_stats.equipment[slot_name]
|
|
equip_data[slot_name] = eq.save() if eq else null
|
|
if player.has_method("_apply_inventory_and_equipment_from_server"):
|
|
player._apply_inventory_and_equipment_from_server.rpc_id(owner_id, inv_data, equip_data)
|
|
|
|
# Show floating text with item name (uppercase)
|
|
var items_texture = load(item.spritePath)
|
|
var display_text = item.item_name.to_upper() # Always uppercase
|
|
var text_color = Color.WHITE
|
|
|
|
# Color code based on item type
|
|
if item.item_type == Item.ItemType.Equippable:
|
|
text_color = Color.CYAN # Cyan for equipment
|
|
elif item.item_type == Item.ItemType.Restoration:
|
|
text_color = Color.GREEN # Green for consumables
|
|
|
|
_show_floating_text(player, display_text, text_color, 0.5, 0.5, items_texture, item.spriteFrames.x, item.spriteFrames.y, item.spriteFrame, item)
|
|
|
|
# Sync floating text to client via GameWorld to avoid loot node path RPCs
|
|
if multiplayer.has_multiplayer_peer() and player.get_multiplayer_authority() != 1:
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if game_world and game_world.has_method("_sync_loot_floating_text"):
|
|
game_world._sync_loot_floating_text.rpc_id(player.get_multiplayer_authority(), loot_type, display_text, text_color, item.spriteFrame, player.get_multiplayer_authority())
|
|
|
|
self.visible = false
|
|
|
|
# Wait for sound to finish before removing
|
|
if sfx_loot_collect and sfx_loot_collect.playing:
|
|
await sfx_loot_collect.finished
|
|
queue_free()
|
|
|
|
var processing_pickup: bool = false # Mutex to prevent concurrent pickup processing
|
|
|
|
@rpc("any_peer", "reliable")
|
|
func _request_pickup(player_peer_id: int):
|
|
# Server receives pickup request from client
|
|
print("Loot: _request_pickup RPC received on server for player_peer_id: ", player_peer_id, " is_server: ", multiplayer.is_server())
|
|
|
|
if not multiplayer.is_server():
|
|
print("Loot: _request_pickup called on non-server, ignoring")
|
|
return
|
|
|
|
# Check cooldown: prevent player from picking up their own dropped item for 5 seconds
|
|
if has_meta("dropped_by_peer_id") and has_meta("drop_time"):
|
|
var dropped_by_peer_id = get_meta("dropped_by_peer_id")
|
|
var drop_time = get_meta("drop_time")
|
|
var current_time = Time.get_ticks_msec()
|
|
var time_since_drop = (current_time - drop_time) / 1000.0 # Convert to seconds
|
|
|
|
if player_peer_id == dropped_by_peer_id and time_since_drop < 5.0:
|
|
# Player can't pick up their own dropped item for 5 seconds
|
|
print("Loot: Player ", player_peer_id, " cannot pick up item they dropped (", time_since_drop, "s ago, need 5s cooldown)")
|
|
return
|
|
|
|
# Use mutex to prevent concurrent processing (race condition protection)
|
|
if processing_pickup:
|
|
print("Loot: Pickup already being processed, ignoring duplicate request")
|
|
return
|
|
|
|
# Check if already collected (this prevents race conditions with Area2D signals)
|
|
if collected:
|
|
print("Loot: Already collected (collected=", collected, "), ignoring pickup request")
|
|
return
|
|
|
|
# Set mutex and mark as collected IMMEDIATELY to prevent any race conditions
|
|
processing_pickup = true
|
|
collected = true
|
|
print("Loot: Marked as collected=true and set processing_pickup=true at start of _request_pickup")
|
|
|
|
# Find the player by peer ID
|
|
var player = null
|
|
var players = get_tree().get_nodes_in_group("player")
|
|
print("Loot: Searching for player with peer_id ", player_peer_id, " among ", players.size(), " players")
|
|
for p in players:
|
|
var p_authority = p.get_multiplayer_authority() if "get_multiplayer_authority" in p else -1
|
|
print("Loot: Checking player ", p.name, " authority: ", p_authority)
|
|
if p_authority == player_peer_id:
|
|
player = p
|
|
break
|
|
|
|
if not player:
|
|
print("Loot: ERROR - Could not find player with peer_id ", player_peer_id, " for pickup")
|
|
# Clear mutex and reset collected if player not found (allow retry)
|
|
processing_pickup = false
|
|
collected = false
|
|
return
|
|
|
|
print("Loot: Found player ", player.name, " processing pickup on server")
|
|
# Process pickup on server directly (skip authority check since we've already validated the request came from the right client)
|
|
# Don't call _pickup() because it will check authority and reject client players
|
|
_process_pickup_on_server(player)
|
|
|
|
# Clear mutex after processing completes
|
|
processing_pickup = false
|
|
|
|
# This function can be called directly (not just via RPC) when game_world routes the update
|
|
func _sync_remove():
|
|
# Clients remove loot when any player picks it up
|
|
# Only process if we're not the authority (i.e., we're a client)
|
|
if multiplayer.is_server():
|
|
return # Server ignores its own updates
|
|
|
|
print("Loot: Client received removal sync for loot at ", global_position)
|
|
|
|
# Mark as collected immediately to stop physics and sounds
|
|
collected = true
|
|
|
|
# Play pickup sound on client so they can hear it
|
|
match loot_type:
|
|
LootType.COIN:
|
|
if sfx_coin_collect:
|
|
sfx_coin_collect.play()
|
|
LootType.APPLE, LootType.BANANA, LootType.CHERRY, LootType.ITEM:
|
|
if sfx_loot_collect:
|
|
sfx_loot_collect.play()
|
|
|
|
# Disable pickup area to prevent further collisions
|
|
if pickup_area:
|
|
pickup_area.monitoring = false
|
|
pickup_area.monitorable = false
|
|
|
|
# Hide immediately
|
|
visible = false
|
|
|
|
# Wait for sound to finish before removing (if sound is playing)
|
|
var _sound_playing = false
|
|
if loot_type == LootType.COIN and sfx_coin_collect and sfx_coin_collect.playing:
|
|
_sound_playing = true
|
|
await sfx_coin_collect.finished
|
|
elif loot_type in [LootType.APPLE, LootType.BANANA, LootType.CHERRY, LootType.ITEM] and sfx_loot_collect and sfx_loot_collect.playing:
|
|
_sound_playing = true
|
|
await sfx_loot_collect.finished
|
|
|
|
# Remove from scene
|
|
if not is_queued_for_deletion():
|
|
queue_free()
|
|
|
|
@rpc("any_peer", "reliable")
|
|
func _sync_show_floating_text(loot_type_value: int, text: String, color_value: Color, _value: int, sprite_frame_value: int, player_peer_id: int):
|
|
# Client receives floating text sync from server
|
|
if multiplayer.is_server():
|
|
return # Server ignores this (it's the sender)
|
|
|
|
# Find player by peer ID
|
|
var player = null
|
|
var players = get_tree().get_nodes_in_group("player")
|
|
for p in players:
|
|
if p.get_multiplayer_authority() == player_peer_id:
|
|
player = p
|
|
break
|
|
|
|
if not player or not is_instance_valid(player):
|
|
return # Can't find player
|
|
|
|
# Determine texture and parameters based on loot type
|
|
var item_texture: Texture2D = null
|
|
var sprite_hframes: int = 1
|
|
var sprite_vframes: int = 1
|
|
|
|
match loot_type_value:
|
|
LootType.COIN:
|
|
item_texture = load("res://assets/gfx/pickups/gold_coin.png")
|
|
sprite_hframes = 6
|
|
sprite_vframes = 1
|
|
LootType.APPLE, LootType.BANANA, LootType.CHERRY, LootType.KEY:
|
|
item_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
sprite_hframes = 20
|
|
sprite_vframes = 14
|
|
LootType.ITEM:
|
|
# Item instance - use item's sprite path
|
|
# Note: item data is not available on client in this sync, so we use default
|
|
# The actual item sprite is set when the loot is created
|
|
item_texture = load("res://assets/gfx/pickups/items_n_shit.png")
|
|
sprite_hframes = 20
|
|
sprite_vframes = 14
|
|
|
|
# Show floating text on client
|
|
_show_floating_text(player, text, color_value, 0.5, 0.5, item_texture, sprite_hframes, sprite_vframes, sprite_frame_value)
|
|
|
|
func _show_floating_text(player: Node, text: String, color: Color, show_time: float = 0.5, fade_time: float = 0.5, item_texture: Texture2D = null, sprite_hframes: int = 1, sprite_vframes: int = 1, sprite_frame: int = 0, item = null):
|
|
# Create floating text and item graphic above player's head
|
|
# Shows for show_time seconds, then fades out over fade_time seconds
|
|
var floating_text_scene = preload("res://scenes/floating_text.tscn")
|
|
if floating_text_scene and player and is_instance_valid(player):
|
|
var floating_text = floating_text_scene.instantiate()
|
|
var parent = player.get_parent()
|
|
if parent:
|
|
parent.add_child(floating_text)
|
|
floating_text.global_position = Vector2(player.global_position.x, player.global_position.y - 20)
|
|
floating_text.setup(text, color, show_time, fade_time, item_texture, sprite_hframes, sprite_vframes, sprite_frame, item)
|