A!leys Galerie

extends CharacterBody2D

# Quantum Lava Runner - Player movement with quantum collision
# Features:
# - Normal top-down RPG movement (WASD or arrow keys)
# - Quantum phase ability (spacebar) to temporarily ignore collision with hazards
# - Gravity-based movement with a twist: quantum uncertainty causes slight random jitter during phasing
# - Health system that depletes when hitting hazards while not phasing
# - Visual feedback for quantum state (shimmering effect)

class_name QuantumPlayer

@export var speed: float = 300.0
@export var acceleration: float = 10.0
@export var friction: float = 10.0
@export var gravity: float = 500.0
@export var jump_force: float = -500.0
@export var max_health: int = 100
@export var quantum_duration: float = 2.0
@export var quantum_jitter_strength: float = 0.5
@export var quantum_shimmer_speed: float = 1.5

@onready var sprite: Sprite2D = $Sprite2D
@onready var health_bar: ProgressBar = $HealthBar
@onready var quantum_particle: Particle2DEmitter2D = $QuantumParticle

var velocity: Vector2 = Vector2.ZERO
var gravity_dir: Vector2 = Vector2.DOWN
var health: int = 100
var is_quantum: bool = false
var quantum_timer: float = 0.0
var jitter_offset: Vector2 = Vector2.ZERO

func _ready():
	health = max_health
	health_bar.value = float(health) / max_health
	quantum_particle.paused = true

func _physics_process(delta):
	# Handle quantum state
	if is_quantum:
		quantum_timer -= delta
		if quantum_timer <= 0.0:
			is_quantum = false
			quantum_particle.paused = true
			sprite.modulate = Color.WHITE

	# Apply quantum jitter effect if active
	if is_quantum:
		jitter_offset.x = randf_range(-quantum_jitter_strength, quantum_jitter_strength)
		jitter_offset.y = randf_range(-quantum_jitter_strength, quantum_jitter_strength)
		position += jitter_offset

	# Calculate input direction
	var input_dir: Vector2 = Vector2.ZERO
	if Input.is_action_pressed("ui_right"):
		input_dir.x += 1
	if Input.is_action_pressed("ui_left"):
		input_dir.x -= 1
	if Input.is_action_pressed("ui_down"):
		input_dir.y += 1
	if Input.is_action_pressed("ui_up"):
		input_dir.y -= 1

	# Quantum phase ability
	if Input.is_action_just_pressed("ui_accept") and !is_quantum:
		StartQuantumPhase()

	# Apply gravity (with quantum twist - gravity is weaker during phase)
	var gravity_force: Vector2 = gravity_dir * gravity
	if is_quantum:
		gravity_force *= 0.3  # Reduced gravity during quantum phase

	# Calculate velocity
	if is_quantum:
		# During quantum phase, movement is less precise but faster
		var target_velocity: Vector2 = input_dir.normalized() * (speed * 1.3)
		velocity = velocity.move_toward(target_velocity, acceleration * 1.5)
		velocity = velocity.slide(velocity.length() * 0.8)  # Slight sliding effect
	else:
		# Normal movement with proper acceleration and friction
		var target_velocity: Vector2 = input_dir.normalized() * speed
		if target_velocity.length() > 0:
			velocity = velocity.move_toward(target_velocity, acceleration)
		velocity.x *= max(0, 1 - friction * delta)

	# Apply gravity
	velocity.y += gravity_force.y * delta

	# Move the player
	if not is_quantum:
		var was_on_floor: bool = is_on_floor()
		var collision_normal: Vector2 = Vector2.ZERO
		velocity = move_and_slide(velocity, collision_normal, false, 0, 0.001)
		if was_on_floor and collision_normal.y < 0:
			velocity.y = 0  # Stop vertical velocity when on ground

	# Quantum movement (ignores collisions but still respects world boundaries)
	if is_quantum:
		position += velocity * delta
		# Ensure player stays within screen bounds during quantum phase
		var screen_size: Vector2 = get_viewport_rect().size
		var camera_pos: Vector2 = get_global_mouse_position() - get_viewport().get_size() / 2
		position.x = clamp(position.x, camera_pos.x + 16, camera_pos.x + screen_size.x - 16)
		position.y = clamp(position.y, camera_pos.y + 16, camera_pos.y + screen_size.y - 16)

	# Check for hazard collisions (only when not in quantum phase)
	if not is_quantum and is_on_hazard():
		TakeDamage(10)
		velocity.y = jump_force  # Knockback effect

	# Update health bar
	health_bar.value = float(health) / max_health
	if health <= 0:
		queue_free()

func StartQuantumPhase():
	is_quantum = true
	quantum_timer = quantum_duration
	quantum_particle.paused = false
	sprite.modulate = Color(1, 1, 1, 0.7)  # Slightly transparent during phase
	emit_signal("quantum_phase_started")

func TakeDamage(amount: int):
	health -= amount
	if health < 0:
		health = 0
	emit_signal("health_changed", health)

func is_on_hazard() -> bool:
	# Check if player is colliding with hazards (areas marked as "Hazard")
	var space_state: SpaceState2D = get_world_2d().direct_space_state
	var query: Dictionary = {
		"collide_with_bodies": true,
		"collide_with_areas": true,
		"shape_index": 0  # Use player's collision shape
	}
	var results: PoolVector2Array = space_state.intersect_point(position, query)
	for result in results:
		if result.is_in_group("Hazard"):
			return true
	return false

# Called when the player jumps (can be connected to input event)
func Jump():
	if is_on_floor():
		velocity.y = jump_force
	.emit_signal("jump_started")