420 lines
12 KiB
GDScript
420 lines
12 KiB
GDScript
extends CharacterBody2D
|
|
|
|
# Bomb - Explosive projectile that can be thrown or placed
|
|
|
|
@export var fuse_duration: float = 3.0 # Time until explosion
|
|
@export var base_damage: float = 50.0 # Base damage (increased from 30)
|
|
@export var damage_radius: float = 48.0 # Area of effect radius (48x48)
|
|
@export var screenshake_strength: float = 5.0 # Base screenshake strength
|
|
|
|
var player_owner: Node = null
|
|
var is_fused: bool = false
|
|
var fuse_timer: float = 0.0
|
|
var is_thrown: bool = false # True if thrown by Dwarf, false if placed
|
|
var is_exploding: bool = false
|
|
var explosion_frame: int = 0
|
|
var explosion_timer: float = 0.0
|
|
|
|
# Z-axis physics (like interactable_object)
|
|
var position_z: float = 0.0
|
|
var velocity_z: float = 0.0
|
|
var gravity_z: float = 500.0
|
|
var is_airborne: bool = false
|
|
var throw_velocity: Vector2 = Vector2.ZERO
|
|
|
|
# Blinking animation
|
|
var blink_timer: float = 0.0
|
|
var bomb_visible: bool = true # Renamed to avoid shadowing CanvasItem.is_visible
|
|
var blink_start_time: float = 1.0 # Start blinking 1 second before explosion
|
|
|
|
# Collection
|
|
var can_be_collected: bool = false
|
|
var collection_delay: float = 0.2 # Can be collected after 0.2 seconds
|
|
|
|
@onready var sprite = $Sprite2D
|
|
@onready var explosion_sprite = $ExplosionSprite
|
|
@onready var shadow = $Shadow
|
|
@onready var bomb_area = $BombArea
|
|
@onready var collection_area = $CollectionArea
|
|
@onready var fuse_particles = $FuseParticles
|
|
@onready var fuse_light = $FuseLight
|
|
@onready var explosion_light = $ExplosionLight
|
|
|
|
# Damage area (larger than collision)
|
|
var damage_area_shape: CircleShape2D = null
|
|
|
|
func _ready():
|
|
# Set collision layer to 2 (interactable objects) so it can be grabbed
|
|
collision_layer = 2
|
|
collision_mask = 1 | 2 | 64 # Collide with players, objects, and walls
|
|
|
|
# Connect area signals
|
|
if bomb_area and not bomb_area.body_entered.is_connected(_on_bomb_area_body_entered):
|
|
bomb_area.body_entered.connect(_on_bomb_area_body_entered)
|
|
if collection_area and not collection_area.body_entered.is_connected(_on_collection_area_body_entered):
|
|
collection_area.body_entered.connect(_on_collection_area_body_entered)
|
|
|
|
# Ensure bomb sprite is visible
|
|
if sprite:
|
|
sprite.visible = true
|
|
|
|
# Hide explosion sprite initially
|
|
if explosion_sprite:
|
|
explosion_sprite.visible = false
|
|
|
|
# Setup damage area (48x48 radius)
|
|
if bomb_area:
|
|
var collision_shape = bomb_area.get_node_or_null("CollisionShape2D")
|
|
if collision_shape:
|
|
damage_area_shape = CircleShape2D.new()
|
|
damage_area_shape.radius = damage_radius / 2.0 # 24 pixel radius for 48x48
|
|
collision_shape.shape = damage_area_shape
|
|
|
|
# Start fuse if not thrown (placed bomb starts fusing immediately)
|
|
if not is_thrown:
|
|
_start_fuse()
|
|
|
|
func setup(target_position: Vector2, owner_player: Node, throw_force: Vector2 = Vector2.ZERO, thrown: bool = false):
|
|
# Don't overwrite position if already set (for thrown bombs)
|
|
if not thrown:
|
|
global_position = target_position
|
|
|
|
player_owner = owner_player
|
|
is_thrown = thrown
|
|
throw_velocity = throw_force
|
|
|
|
if is_thrown:
|
|
# Thrown bomb - start airborne
|
|
is_airborne = true
|
|
position_z = 2.5
|
|
velocity_z = 100.0
|
|
# Make sure sprite is visible
|
|
if sprite:
|
|
sprite.visible = true
|
|
# Start fuse after landing
|
|
else:
|
|
# Placed bomb - start fusing immediately
|
|
_start_fuse()
|
|
|
|
func _start_fuse():
|
|
if is_fused:
|
|
return
|
|
|
|
is_fused = true
|
|
fuse_timer = 0.0
|
|
|
|
# Play fuse sound
|
|
if has_node("SfxFuse"):
|
|
$SfxFuse.play()
|
|
|
|
# Start fuse particles
|
|
if fuse_particles:
|
|
fuse_particles.emitting = true
|
|
|
|
# Enable fuse light
|
|
if fuse_light:
|
|
fuse_light.enabled = true
|
|
|
|
print("Bomb fuse started!")
|
|
|
|
func _physics_process(delta):
|
|
if is_exploding:
|
|
# Handle explosion animation
|
|
explosion_timer += delta
|
|
if explosion_sprite:
|
|
# Play 9 frames of explosion animation at ~15 FPS
|
|
if explosion_timer >= 0.06666667: # ~15 FPS
|
|
explosion_timer = 0.0
|
|
explosion_frame += 1
|
|
if explosion_frame < 9:
|
|
explosion_sprite.frame = explosion_frame
|
|
else:
|
|
# Explosion animation complete - remove
|
|
queue_free()
|
|
return
|
|
|
|
# Update fuse timer
|
|
if is_fused:
|
|
fuse_timer += delta
|
|
|
|
# Start blinking when close to explosion
|
|
if fuse_timer >= (fuse_duration - blink_start_time):
|
|
blink_timer += delta
|
|
if blink_timer >= 0.1: # Blink every 0.1 seconds
|
|
blink_timer = 0.0
|
|
bomb_visible = not bomb_visible
|
|
if sprite:
|
|
sprite.modulate.a = 1.0 if bomb_visible else 0.3
|
|
|
|
# Explode when fuse runs out
|
|
if fuse_timer >= fuse_duration:
|
|
_explode()
|
|
return
|
|
|
|
# Z-axis physics (if thrown)
|
|
if is_thrown and is_airborne:
|
|
# Apply gravity
|
|
velocity_z -= gravity_z * delta
|
|
position_z += velocity_z * delta
|
|
|
|
# Update sprite position based on height
|
|
if sprite:
|
|
sprite.position.y = -position_z * 0.5
|
|
var height_scale = 1.0 - (position_z / 50.0) * 0.2
|
|
sprite.scale = Vector2.ONE * max(0.8, height_scale)
|
|
|
|
# Update shadow
|
|
if shadow:
|
|
var shadow_scale = 1.0 - (position_z / 75.0) * 0.5
|
|
shadow.scale = Vector2.ONE * max(0.5, shadow_scale)
|
|
shadow.modulate.a = 0.5 - (position_z / 100.0) * 0.3
|
|
|
|
# Apply throw velocity
|
|
velocity = throw_velocity
|
|
|
|
# Check if landed
|
|
if position_z <= 0.0:
|
|
_land()
|
|
else:
|
|
# On ground - reset sprite/shadow
|
|
if sprite:
|
|
sprite.position.y = 0
|
|
sprite.scale = Vector2.ONE
|
|
if shadow:
|
|
shadow.scale = Vector2.ONE
|
|
shadow.modulate.a = 0.5
|
|
|
|
# Apply friction if on ground
|
|
if not is_airborne:
|
|
throw_velocity = throw_velocity.lerp(Vector2.ZERO, delta * 5.0)
|
|
if throw_velocity.length() < 5.0:
|
|
throw_velocity = Vector2.ZERO
|
|
velocity = throw_velocity
|
|
|
|
# Move
|
|
move_and_slide()
|
|
|
|
# Check for collisions while airborne (instant explode on enemy/player hit)
|
|
if is_airborne and throw_velocity.length() > 50.0:
|
|
for i in get_slide_collision_count():
|
|
var collision = get_slide_collision(i)
|
|
var collider = collision.get_collider()
|
|
|
|
if collider and (collider.is_in_group("player") or collider.is_in_group("enemy")):
|
|
if collider != player_owner:
|
|
# Instant explode on hit
|
|
_explode()
|
|
return
|
|
|
|
# Enable collection after delay
|
|
if is_fused and not can_be_collected:
|
|
if fuse_timer >= collection_delay:
|
|
can_be_collected = true
|
|
if collection_area:
|
|
collection_area.monitoring = true
|
|
|
|
func _land():
|
|
is_airborne = false
|
|
position_z = 0.0
|
|
velocity_z = 0.0
|
|
|
|
# Start fuse when landing
|
|
if not is_fused:
|
|
_start_fuse()
|
|
|
|
func _explode():
|
|
if is_exploding:
|
|
return
|
|
|
|
is_exploding = true
|
|
|
|
# Hide bomb sprite, show explosion
|
|
if sprite:
|
|
sprite.visible = false
|
|
if explosion_sprite:
|
|
explosion_sprite.visible = true
|
|
explosion_sprite.frame = 0
|
|
explosion_frame = 0
|
|
explosion_timer = 0.0
|
|
|
|
# Stop fuse sound and particles
|
|
if has_node("SfxFuse"):
|
|
$SfxFuse.stop()
|
|
if fuse_particles:
|
|
fuse_particles.emitting = false
|
|
|
|
# Disable fuse light, enable explosion light
|
|
if fuse_light:
|
|
fuse_light.enabled = false
|
|
if explosion_light:
|
|
explosion_light.enabled = true
|
|
# Fade out explosion light over time
|
|
var tween = create_tween()
|
|
tween.tween_property(explosion_light, "energy", 0.0, 0.3)
|
|
tween.tween_callback(func(): if explosion_light: explosion_light.enabled = false)
|
|
|
|
# Play explosion sound
|
|
if has_node("SfxExplosion"):
|
|
$SfxExplosion.play()
|
|
|
|
# Deal area damage
|
|
_deal_explosion_damage()
|
|
|
|
# Cause screenshake
|
|
_cause_screenshake()
|
|
|
|
# Disable collision
|
|
if bomb_area:
|
|
bomb_area.set_deferred("monitoring", false)
|
|
if collection_area:
|
|
collection_area.set_deferred("monitoring", false)
|
|
|
|
print("Bomb exploded!")
|
|
|
|
func _deal_explosion_damage():
|
|
if not bomb_area:
|
|
return
|
|
|
|
# Get all bodies in explosion radius
|
|
var bodies = bomb_area.get_overlapping_bodies()
|
|
|
|
# Calculate total damage including strength bonus
|
|
var total_damage = base_damage
|
|
|
|
# Add strength-based bonus damage
|
|
if player_owner and player_owner.character_stats:
|
|
var strength = player_owner.character_stats.baseStats.str + player_owner.character_stats.get_pass("str")
|
|
# Add 1.5 damage per strength point
|
|
var strength_bonus = strength * 1.5
|
|
total_damage += strength_bonus
|
|
print("Bomb damage: base=", base_damage, " + str_bonus=", strength_bonus, " (STR=", strength, ") = ", total_damage)
|
|
|
|
for body in bodies:
|
|
# CRITICAL: Only the bomb owner (authority) should deal damage
|
|
if player_owner and not player_owner.is_multiplayer_authority():
|
|
continue
|
|
|
|
# Note: Removed the check that skips player_owner - bombs now damage the player who used them!
|
|
|
|
# Calculate distance for damage falloff
|
|
var distance = global_position.distance_to(body.global_position)
|
|
var damage_multiplier = 1.0 - (distance / damage_radius) # Linear falloff
|
|
damage_multiplier = max(0.1, damage_multiplier) # Minimum 10% damage
|
|
var final_damage = total_damage * damage_multiplier
|
|
|
|
# Deal damage to players
|
|
if body.is_in_group("player") and body.has_method("rpc_take_damage"):
|
|
var attacker_pos = player_owner.global_position if player_owner else global_position
|
|
var player_peer_id = body.get_multiplayer_authority()
|
|
|
|
if player_peer_id != 0:
|
|
if multiplayer.is_server() and player_peer_id == multiplayer.get_unique_id():
|
|
body.rpc_take_damage(final_damage, attacker_pos)
|
|
else:
|
|
body.rpc_take_damage.rpc_id(player_peer_id, final_damage, attacker_pos)
|
|
else:
|
|
body.rpc_take_damage.rpc(final_damage, attacker_pos)
|
|
|
|
print("Bomb hit player: ", body.name, " for ", final_damage, " damage!")
|
|
|
|
# Deal damage to enemies
|
|
elif body.is_in_group("enemy") and body.has_method("rpc_take_damage"):
|
|
var attacker_pos = player_owner.global_position if player_owner else global_position
|
|
var enemy_peer_id = body.get_multiplayer_authority()
|
|
|
|
if enemy_peer_id != 0:
|
|
if multiplayer.is_server() and enemy_peer_id == multiplayer.get_unique_id():
|
|
body.rpc_take_damage(final_damage, attacker_pos, false, false, false)
|
|
else:
|
|
body.rpc_take_damage.rpc_id(enemy_peer_id, final_damage, attacker_pos, false, false, false)
|
|
else:
|
|
body.rpc_take_damage.rpc(final_damage, attacker_pos, false, false, false)
|
|
|
|
print("Bomb hit enemy: ", body.name, " for ", final_damage, " damage!")
|
|
|
|
func _cause_screenshake():
|
|
# Calculate screenshake based on distance from local players
|
|
var game_world = get_tree().get_first_node_in_group("game_world")
|
|
if not game_world:
|
|
return
|
|
|
|
# Get local players from player_manager
|
|
var player_manager = game_world.get_node_or_null("PlayerManager")
|
|
if not player_manager or not player_manager.has_method("get_local_players"):
|
|
return
|
|
|
|
var local_players = player_manager.get_local_players()
|
|
if local_players.is_empty():
|
|
return
|
|
|
|
# Find closest local player
|
|
var min_distance = INF
|
|
for player in local_players:
|
|
if not is_instance_valid(player):
|
|
continue
|
|
var distance = global_position.distance_to(player.global_position)
|
|
min_distance = min(min_distance, distance)
|
|
|
|
# Calculate screenshake strength (inverse distance, capped)
|
|
var shake_strength = screenshake_strength / max(1.0, min_distance / 50.0)
|
|
shake_strength = min(shake_strength, screenshake_strength * 2.0) # Cap at 2x base
|
|
|
|
# Apply screenshake
|
|
if game_world.has_method("add_screenshake"):
|
|
game_world.add_screenshake(shake_strength, 0.3) # 0.3 second duration
|
|
|
|
func _on_bomb_area_body_entered(_body):
|
|
# This is for explosion damage (handled in _deal_explosion_damage)
|
|
pass
|
|
|
|
func can_be_grabbed() -> bool:
|
|
# Bomb can be grabbed if it's fused and can be collected
|
|
return is_fused and can_be_collected and not is_exploding
|
|
|
|
func on_grabbed(by_player):
|
|
# When bomb is grabbed, collect it immediately (don't wait for release)
|
|
if not can_be_collected or is_exploding:
|
|
return
|
|
|
|
if not by_player.character_stats:
|
|
return
|
|
|
|
var offhand_item = by_player.character_stats.equipment.get("offhand", null)
|
|
var can_collect = false
|
|
|
|
if not offhand_item:
|
|
# Empty offhand - can collect
|
|
can_collect = true
|
|
elif offhand_item.item_name == "Bomb":
|
|
# Already has bombs - can stack
|
|
can_collect = true
|
|
|
|
if can_collect:
|
|
# Create bomb item
|
|
var bomb_item = ItemDatabase.create_item("bomb")
|
|
if bomb_item:
|
|
bomb_item.quantity = 1
|
|
|
|
if not offhand_item:
|
|
# Equip to offhand
|
|
by_player.character_stats.equipment["offhand"] = bomb_item
|
|
else:
|
|
# Add to existing stack
|
|
offhand_item.quantity += 1
|
|
|
|
by_player.character_stats.character_changed.emit(by_player.character_stats)
|
|
|
|
# Play pickup sound
|
|
if has_node("SfxPickup"):
|
|
$SfxPickup.play()
|
|
|
|
print(by_player.name, " collected bomb!")
|
|
|
|
# Remove bomb immediately
|
|
queue_free()
|
|
|
|
func _on_collection_area_body_entered(_body):
|
|
# This is a backup - main collection happens via can_be_grabbed/on_grabbed
|
|
# But we can also handle it here if needed
|
|
pass
|