func _physics_process(_delta: float) -> void:
	velocity.y += gravity
	if velocity.y > max_fall_velocity:
		velocity.y = max_fall_velocity
	
	if use_accelerometer:
		var mobile_input = Input.get_accelerometer()
		velocity.x = mobile_input.x * accelerometer_speed
	else:
		var direction = Input.get_axis("move_left", "move_right")
		if direction:
			velocity.x = direction * speed
		else:
			velocity.x = move_toward(velocity.x, 0, speed)
	
	move_and_slide()

var score: int = 0
var highscore: int = 0
var save_file_path = "user://highscore.save"

func _ready() -> void:
	hud.set_score(0)

func _on_player_died():
	hud.visible = false

	if score > highscore:
		highscore = score
		save_score()

	player_died.emit(score, highscore)

func save_score():
	var file = FileAccess.open(save_file_path, FileAccess.WRITE)
	file.store_var(highscore)
	file.close()
	
func load_score():
	if FileAccess.file_exists(save_file_path):
		var file = FileAccess.open(save_file_path, FileAccess.READ)
		highscore = file.get_var()
		file.close()
	else:
		highscore = 0

func appear():
	visible = true
	
	var tween = get_tree().create_tween()
	tween.set_pause_mode(Tween.TWEEN_PAUSE_PROCESS)
	tween.tween_property(self, "modulate:a", 1.0, fade_duration)
	return tween

func _on_game_pause_game():
	get_tree().paused = true
	screens.pause_game()

await get_tree().create_timer(0.75).timeout

func _ready() -> void:
	DisplayServer.window_set_window_event_callback(_on_window_event)

func _on_window_event(event):
	match event:
		DisplayServer.WINDOW_EVENT_FOCUS_IN:
			print("Focus in")
		DisplayServer.WINDOW_EVENT_FOCUS_OUT:
			print("Focus Out")
		DisplayServer.WINDOW_EVENT_CLOSE_REQUEST:
			get_tree().quit()

func jump():
	velocity.y = jump_velocity
	SoundFX.play("Jump")

extends Node

var sounds = {
	"Click": load("res://assets/sound/Click.wav"),
	"Fall": load("res://assets/sound/Fall.wav"),
	"Jump": load("res://assets/sound/Jump.wav"),
}

@onready var sound_players = get_children()

func play(sound_name):
	var sound_to_play = sounds[sound_name]
	for sound_player in sound_players:
		if !sound_player.playing:
			sound_player.stream = sound_to_play
			sound_player.play()
			return
			

extends Node

signal unlock_new_skin

var google_payment = null
var new_skin_sku = "new_player_skin"
var new_skin_token = ""

func _ready() -> void:
	if Engine.has_singleton("GodotGooglePlayBilling"):
		google_payment = Engine.get_singleton("GodotGooglePlayBilling")
		MyUtility.add_log_msg("Android IAP support is enabled")
		
		google_payment.connected.connect(_on_connected)
		google_payment.startConnection()
		google_payment.connect_error.connect(_on_connect_error)
		google_payment.disconnected.connect(_on_disconnected)
		google_payment.sku_details_query_completed.connect(_on_sku_details_query_completed)
		google_payment.sku_details_query_error.connect(_on_sku_details_query_error)
		google_payment.purchases_updated.connect(_on_purchases_updated)
		google_payment.purchase_error.connect(_on_purchase_error)
		google_payment.purchase_acknowledged.connect(_on_purchase_acknowledged)
		google_payment.purchase_acknowledgement_error.connect(_on_purchase_acknowledgement_error)
		google_payment.query_purchases_response.connect(_on_query_purchases_response)
		google_payment.purchase_consumed.connect(_on_purchase_consumed)
		google_payment.purchase_consumption_error.connect(_on_purchase_consumption_error)
	else:
		MyUtility.add_log_msg("Android IAP support is not available")

func purchase_skin():
	if google_payment:
		var response = google_payment.purchase(new_skin_sku)
		MyUtility.add_log_msg("Purchase attempted, response " + str(response.status))
		if response.status != OK:
			MyUtility.add_log_msg("Error purchasing skin")

func reset_purchases():
	if google_payment:
		if !new_skin_token.is_empty():
			google_payment.consumePurchases(new_skin_token)

func _on_connected():
	MyUtility.add_log_msg("Connected")
	
	google_payment.querySkuDetails([new_skin_sku], "inapp")

func _on_connect_error(response_id, debug_msg):
	MyUtility.add_log_msg("Connect error, response id: " + str(response_id) + " debug msg: " + debug_msg)
	
func _on_disconnected():
	MyUtility.add_log_msg("Disconnected")
	
func _on_sku_details_query_completed(skus):
	MyUtility.add_log_msg("Sku details query completeld")
	for sku in skus:
		MyUtility.add_log_msg("Sku:")
		MyUtility.add_log_msg(str(sku))
	google_payment.queryPurchases("inapp")

func _on_sku_details_query_error(response_id, error_message, skus):
	MyUtility.add_log_msg("Sku query error, response id: " + str(response_id) + ", message: " + str(error_message) + ", skus: " + str(skus))

func _on_purchases_updated(purchases):
	if purchases.size() > 0:
		var purchase = purchases[0]
		var purchase_sku = purchase["skus"][0]
		MyUtility.add_log_msg("Purchased item with sku: " + purchase_sku)
		if purchase_sku == new_skin_sku:
			new_skin_token = purchase.purchase_token
			google_payment.acknowledgePurchase(purchase.purchase_token)
			
	
func _on_purchase_error(response_id, error_message):
	MyUtility.add_log_msg("Purchase error, response id: " + str(response_id) + " error msg: " + error_message)
	
func _on_purchase_acknowledged(purchase_token):
	MyUtility.add_log_msg("Purchase acknowledged successfully")
	
	if !new_skin_token.is_empty():
		if new_skin_token == purchase_token:
			MyUtility.add_log_msg("Unlocking new skin")
			unlock_new_skin.emit()
	
func _on_purchase_acknowledgement_error(response_id, error_message, purchase_token):
	MyUtility.add_log_msg("Purchase acknowledgement error, response id: " + str(response_id) + ", message: " + str(error_message) + ", token: " + str(purchase_token))
	
func _on_query_purchases_response(query_result):
	if query_result.status == OK:
		MyUtility.add_log_msg("Query purchases was successful")
		var purchases = query_result.purchases
		var purchase = purchases[0]
		var purchase_sku = purchase["skus"][0]
		if new_skin_sku == purchase_sku:
			new_skin_token = purchase.purchase_token
			if !purchase.is_acknowledged:
				google_payment.acknowledgePurchase(purchase.purchase_token)
			else:
				unlock_new_skin.emit()
				MyUtility.add_log_msg("Unlocking new skin because it was purchased previously")
	else:
		MyUtility.add_log_msg("Query purchases failed")

func _on_purchase_consumed(purchase_token):
	MyUtility.add_log_msg("Purchase consumed successfully")

func _on_purchase_consumption_error(response_id, error_message, purchase_token):
	MyUtility.add_log_msg("Purchase consumption error, response id: " + str(response_id) + ", message: " + str(error_message) + ", token: " + str(purchase_token))
	

extends RigidBody2D

enum ANIMAL_STATE {
	READY,
	DRAG,
	RELEASE
}

var _state: ANIMAL_STATE = ANIMAL_STATE.READY

func _physics_process(delta: float) -> void:
	update(delta)

func set_new_state(new_state: ANIMAL_STATE):
	_state = new_state
	if _state == ANIMAL_STATE.RELEASE:
		freeze = false
	elif _state == ANIMAL_STATE.DRAG:
		pass

func detect_release():
	if _state == ANIMAL_STATE.DRAG:
		if Input.is_action_just_released("drag"):
			set_new_state(ANIMAL_STATE.RELEASE)
			return true
	return false

func update_drag():
	if detect_release():
		return

	var gmp = get_global_mouse_position()
	position = gmp

func update(delta):
	match _state:
		ANIMAL_STATE.DRAG:
			update_drag()

func die():
	SignalManager.on_animal_died.emit()
	queue_free()

func _on_visible_on_screen_notifier_2d_screen_exited() -> void:
	die()

func _on_input_event(viewport: Node, event: InputEvent, shape_idx: int) -> void:
	if _state == ANIMAL_STATE.READY and event.is_action_pressed("drag"):
		set_new_state(ANIMAL_STATE.DRAG)
		

extends CharacterBody2D
class_name Player


@onready var sprite_2d: Sprite2D = $Sprite2D
@onready var animation_player: AnimationPlayer = $AnimationPlayer

const GRAVITY: float = 1000.0
const RUN_SPEED: float = 120.0
const MAX_FALL: float = 400.0
const HURT_TIME: float = 0.3
const JUMP_VELOCITY: float = -400.0

enum PLAYER_STATE {
	IDLE,
	RUN,
	JUMP,
	FALL,
	HURT
}

var _state: PLAYER_STATE = PLAYER_STATE.IDLE

func _physics_process(delta: float) -> void:
	if !is_on_floor():
		velocity.y += GRAVITY * delta
	
	get_input()
	move_and_slide()
	calculate_states()

func get_input():
	velocity.x = 0
	
	if Input.is_action_pressed("left"):
		velocity.x = -RUN_SPEED
		sprite_2d.flip_h = true
	elif Input.is_action_pressed("right"):
		velocity.x = RUN_SPEED
		sprite_2d.flip_h = false
	
	if Input.is_action_just_pressed("jump") and is_on_floor():
		velocity.y = JUMP_VELOCITY
	
	velocity.y = clampf(velocity.y, JUMP_VELOCITY, MAX_FALL)
	
func calculate_states():
	if _state == PLAYER_STATE.HURT:
		return
	
	if is_on_floor():
		if velocity.x == 0:
			set_state(PLAYER_STATE.IDLE)
		else:
			set_state(PLAYER_STATE.RUN)
	else:
		if velocity.y > 0:
			set_state(PLAYER_STATE.FALL)
		else:
			set_state(PLAYER_STATE.JUMP)

func set_state(new_state: PLAYER_STATE):
	if new_state == _state:
		return
	
	_state = new_state
	
	match _state:
		PLAYER_STATE.IDLE:
			animation_player.play("idle")
		PLAYER_STATE.RUN:
			animation_player.play("run")
		PLAYER_STATE.JUMP:
			animation_player.play("jump")
		PLAYER_STATE.FALL:
			animation_player.play("fall")

extends CharacterBody2D
class_name EnemyBase

enum FACING {
	LEFT = -1,
	RIGHT = 1
}

const OFF_SCREEN_KILL_ME: float = 1000.0

@export var default_facing: FACING = FACING.LEFT
@export var points: int = 1
@export var speed: float = 30.0

var _gravity: float = 800.0
var _facing: FACING = default_facing
var _player_ref: Player
var _dying: bool = false

func _ready() -> void:
	_player_ref = get_tree().get_nodes_in_group(GameManager.GROUP_PLAYER)[0]
	
func _physics_process(delta: float) -> void:
	fallen_off()

func fallen_off():
	if global_position.y > OFF_SCREEN_KILL_ME:
		queue_free()

func die():
	if _dying:
		return
		
	_dying = true
	SignalManager.on_enemy_hit.emit(points, global_position)
	set_physics_process(false)
	hide()
	queue_free()

func _on_visible_on_screen_notifier_2d_screen_entered() -> void:
	pass # Replace with function body.


func _on_visible_on_screen_notifier_2d_screen_exited() -> void:
	pass # Replace with function body.

extends EnemyBase

@onready var floor_detection: RayCast2D = $FloorDetection
@onready var animated_sprite_2d: AnimatedSprite2D = $AnimatedSprite2D

func _physics_process(delta: float) -> void:
	super._physics_process(delta)
	
	if !is_on_floor():
		velocity.y += _gravity * delta
	else:
		velocity.x = speed * _facing
	
	move_and_slide()
	
	if is_on_floor():
		if is_on_wall() or !floor_detection.is_colliding():
			flip_me()
		
func flip_me():
	animated_sprite_2d.flip_h = !animated_sprite_2d.flip_h
	floor_detection.position.x = floor_detection.position.x * -1

	if _facing == FACING.LEFT:
		_facing = FACING.RIGHT
	else:
		_facing = FACING.LEFT

extends EnemyBase

@onready var animated_sprite_2d: AnimatedSprite2D = $AnimatedSprite2D
@onready var jump_timer: Timer = $JumpTimer

const JUMP_VELOCITY: Vector2 = Vector2(100, -150)
const JUMP_WAIT_RANGE: Vector2 = Vector2(2.5, 5.0)

var _jump: bool = false
var _seen_player: bool = false

func _ready() -> void:
	super._ready()
	start_timer()

func _physics_process(delta: float) -> void:
	super._physics_process(delta)
	
	if !is_on_floor():
		velocity.y += _gravity * delta
	else:
		velocity.x = 0
		animated_sprite_2d.play("idle")
	
	apply_jump()
	move_and_slide()
	flip_me()

func apply_jump():
	if !is_on_floor():
		return
	
	if !_seen_player or !_jump:
		return
		
	velocity = JUMP_VELOCITY
	
	if !animated_sprite_2d.flip_h:
		velocity.x = velocity.x * -1
	
	_jump = false
	
	animated_sprite_2d.play("jump")
	start_timer()
	

func flip_me():
	if _player_ref.global_position.x > global_position.x and !animated_sprite_2d.flip_h:
		animated_sprite_2d.flip_h = true
	elif _player_ref.global_position.x < global_position.x and animated_sprite_2d.flip_h:
		animated_sprite_2d.flip_h = false

func start_timer():
	jump_timer.wait_time = randf_range(JUMP_WAIT_RANGE.x, JUMP_WAIT_RANGE.y)
	jump_timer.start()


func _on_jump_timer_timeout() -> void:
	_jump = true

func _on_visible_on_screen_notifier_2d_screen_entered() -> void:
	_seen_player = true

extends EnemyBase

@onready var animated_sprite_2d: AnimatedSprite2D = $AnimatedSprite2D
@onready var player_detector: RayCast2D = $PlayerDetector
@onready var direction_timer: Timer = $DirectionTimer

const FLY_SPEED: Vector2 = Vector2(35, 15)

var _fly_direction: Vector2 = Vector2.ZERO

func _physics_process(delta: float) -> void:
	super._physics_process(delta)
	velocity = _fly_direction
	move_and_slide()

func set_and_flip():
	var x_dir = sign(_player_ref.global_position.x - global_position.x)

	if x_dir > 0:
		animated_sprite_2d.flip_h = true
	else:
		animated_sprite_2d.flip_h = false

	_fly_direction = Vector2(x_dir, 1) * FLY_SPEED

func fly_to_player():
	set_and_flip()
	direction_timer.start()

func _on_visible_on_screen_notifier_2d_screen_entered() -> void:
	animated_sprite_2d.play("fly")
	fly_to_player()

func _on_direction_timer_timeout() -> void:
	fly_to_player()

extends Node

enum BULLET_KEY {
	PLAYER,
	ENEMY
}

const BULLETS = {
	BULLET_KEY.PLAYER: preload("res://scenes/bullets/bullet_player/bullet_player.tscn"),
	BULLET_KEY.ENEMY: preload("res://scenes/bullets/bullet_enemy/bullet_enemy.tscn"),
}

func add_child_deferred(child_to_add):
	get_tree().root.add_child(child_to_add)

func call_add_child(child_to_add):
	call_deferred("add_child_deferred", child_to_add)

func create_bullet(speed: float, direction: Vector2, start_pos: Vector2, life_span: float, key: BULLET_KEY):
	var new_b = BULLETS[key].instantiate()
	new_b.setup(direction, life_span, speed)
	new_b.global_position = start_pos
	call_add_child(new_b)

enum BULLET_KEY {
	PLAYER,
	ENEMY
}

const BULLETS = {
	BULLET_KEY.PLAYER: preload("res://scenes/bullets/bullet_player/bullet_player.tscn"),
	BULLET_KEY.ENEMY: preload("res://scenes/bullets/bullet_enemy/bullet_enemy.tscn"),
}

func add_child_deferred(child_to_add):
	get_tree().root.add_child(child_to_add)

func call_add_child(child_to_add):
	call_deferred("add_child_deferred", child_to_add)

func create_bullet(speed: float, direction: Vector2, start_pos: Vector2, life_span: float, key: BULLET_KEY):
	var new_b = BULLETS[key].instantiate()
	new_b.setup(direction, life_span, speed)
	new_b.global_position = start_pos
	call_add_child(new_b)

extends Node2D

@onready var sound: AudioStreamPlayer2D = $Sound
@onready var shoot_timer: Timer = $ShootTimer

@export var speed: float = 50.0
@export var life_span: float = 10.0
@export var bullet_key: ObjectMaker.BULLET_KEY
@export var shoot_delay: float = 0.7

var _can_shoot: bool = true

func _ready() -> void:
	shoot_timer.wait_time = shoot_delay

func shoot(direction: Vector2):
	if !_can_shoot:
		return
		
	_can_shoot = false
	SoundManager.play_clip(sound, SoundManager.SOUND_LASER)
	ObjectMaker.create_bullet(speed, direction, global_position, life_span, bullet_key)
	shoot_timer.start()

func _on_shoot_timer_timeout() -> void:
	_can_shoot = true

# 追加
@onready var shooter: Node2D = $Shooter

func _physics_process(delta: float) -> void:
	if !is_on_floor():
		velocity.y += GRAVITY * delta
	
	get_input()
	move_and_slide()
	calculate_states()
	update_debug_label()
	
	if Input.is_action_just_pressed("shoot"):
		shoot()

func shoot():
	if sprite_2d.flip_h:
		shooter.shoot(Vector2.LEFT)
	else:
		shooter.shoot(Vector2.RIGHT)

extends Area2D

@onready var animated_sprite_2d: AnimatedSprite2D = $AnimatedSprite2D

const FRUITS: Array = ["melon", "kiwi", "banana", "cherry"]
const GRAVITY: float = 160.0
const JUMP: float = -80.0
const POINTS: int = 2

var _start_y: float
var _speed_y: float = JUMP
var _stopped: bool = false

func _ready() -> void:
	_start_y = global_position.y
	animated_sprite_2d.play(FRUITS.pick_random())

func _process(delta: float) -> void:
	if _stopped:
		return
		
	position.y += _speed_y * delta
	_speed_y += GRAVITY * delta
	
	if global_position.y > _start_y:
		_stopped = true

func kill_me():
	set_process(false)
	hide()
	queue_free()

func _on_life_timer_timeout() -> void:
	kill_me()


func _on_area_entered(area: Area2D) -> void:
	print("Pickup collected")
	SignalManager.on_pickup_hit.emit(POINTS)
	kill_me()

extends Node

enum BULLET_KEY {
	PLAYER,
	ENEMY
}

enum SCENE_KEY {
	EXPLOSION,
	PICKUP
}

const BULLETS = {
	BULLET_KEY.PLAYER: preload("res://scenes/bullets/bullet_player/bullet_player.tscn"),
	BULLET_KEY.ENEMY: preload("res://scenes/bullets/bullet_enemy/bullet_enemy.tscn"),
}

const SIMPLE_SCENES = {
	SCENE_KEY.EXPLOSION: preload("res://scenes/enemy_explosion/enemy_explosion.tscn"),
	SCENE_KEY.PICKUP: preload("res://scenes/fruit_pick_up/fruit_pick_up.tscn")
}


func add_child_deferred(child_to_add):
	get_tree().root.add_child(child_to_add)

func call_add_child(child_to_add):
	call_deferred("add_child_deferred", child_to_add)

func create_bullet(speed: float, direction: Vector2, start_pos: Vector2, life_span: float, key: BULLET_KEY):
	var new_b = BULLETS[key].instantiate()
	new_b.setup(direction, life_span, speed)
	new_b.global_position = start_pos
	call_add_child(new_b)

func create_simple_scene(start_pos: Vector2, key: SCENE_KEY):
	var new_exp = SIMPLE_SCENES[key].instantiate()
	new_exp.global_position = start_pos
	call_add_child(new_exp)

extends CharacterBody2D
class_name EnemyBase

enum FACING {
	LEFT = -1,
	RIGHT = 1
}

const OFF_SCREEN_KILL_ME: float = 1000.0

@export var default_facing: FACING = FACING.LEFT
@export var points: int = 1
@export var speed: float = 30.0

var _gravity: float = 800.0
var _facing: FACING = default_facing
var _player_ref: Player
var _dying: bool = false

func _ready() -> void:
	_player_ref = get_tree().get_nodes_in_group(GameManager.GROUP_PLAYER)[0]
	
func _physics_process(delta: float) -> void:
	fallen_off()

func fallen_off():
	if global_position.y > OFF_SCREEN_KILL_ME:
		queue_free()

func die():
	if _dying:
		return
		
	_dying = true
	SignalManager.on_enemy_hit.emit(points, global_position)
	ObjectMaker.create_simple_scene(global_position, ObjectMaker.SCENE_KEY.EXPLOSION)
	ObjectMaker.create_simple_scene(global_position, ObjectMaker.SCENE_KEY.PICKUP)
	set_physics_process(false)
	hide()
	queue_free()

func _on_visible_on_screen_notifier_2d_screen_entered() -> void:
	pass # Replace with function body.


func _on_visible_on_screen_notifier_2d_screen_exited() -> void:
	pass # Replace with function body.

func _on_hit_box_area_entered(area: Area2D) -> void:
	print("Enemy hit: ", area)
	die()

extends AnimatableBody2D

@export var p1: Marker2D
@export var p2: Marker2D
@export var speed: float = 50.0

var _time_to_move: float = 0.0
var _tween: Tween

func _ready() -> void:
	set_time_to_move()
	set_moving()
	
func _exit_tree() -> void:
	_tween.kill()
	

func set_time_to_move():
	var delta = p1.global_position.distance_to(p2.global_position)
	_time_to_move = delta / speed
	
func set_moving():
	_tween = get_tree().create_tween()
	_tween.set_loops(0)
	_tween.tween_property(self, "global_position", p1.global_position, _time_to_move)
	_tween.tween_property(self, "global_position", p2.global_position, _time_to_move)

extends PathFollow2D

@export var speed: float = 0.2

func _process(delta: float) -> void:
	progress_ratio = progress_ratio + delta * speed

extends ParallaxBackground

var BG_FILES = {
	1: [
		preload("res://assets/backgrounds/game_background_1/layers/sky.png"),
		preload("res://assets/backgrounds/game_background_1/layers/clouds_1.png"),
		preload("res://assets/backgrounds/game_background_1/layers/clouds_2.png"),
		preload("res://assets/backgrounds/game_background_1/layers/clouds_3.png"),
		preload("res://assets/backgrounds/game_background_1/layers/clouds_4.png"),
		preload("res://assets/backgrounds/game_background_1/layers/rocks_1.png"),
		preload("res://assets/backgrounds/game_background_1/layers/rocks_2.png")
	],
	2: [
		preload("res://assets/backgrounds/game_background_2/layers/sky.png"),
		preload("res://assets/backgrounds/game_background_2/layers/birds.png"),
		preload("res://assets/backgrounds/game_background_2/layers/clouds_1.png"),
		preload("res://assets/backgrounds/game_background_2/layers/clouds_2.png"),
		preload("res://assets/backgrounds/game_background_2/layers/clouds_3.png"),
		preload("res://assets/backgrounds/game_background_2/layers/pines.png"),
		preload("res://assets/backgrounds/game_background_2/layers/rocks_1.png"),
		preload("res://assets/backgrounds/game_background_2/layers/rocks_2.png"),
		preload("res://assets/backgrounds/game_background_2/layers/rocks_3.png")
	],
	3: [
		preload("res://assets/backgrounds/game_background_3/layers/sky.png"),
		preload("res://assets/backgrounds/game_background_3/layers/clouds_1.png"),
		preload("res://assets/backgrounds/game_background_3/layers/clouds_2.png"),
		preload("res://assets/backgrounds/game_background_3/layers/ground_1.png"),
		preload("res://assets/backgrounds/game_background_3/layers/ground_2.png"),
		preload("res://assets/backgrounds/game_background_3/layers/ground_3.png"),
		preload("res://assets/backgrounds/game_background_3/layers/plant.png"),
		preload("res://assets/backgrounds/game_background_3/layers/rocks.png")
	],
	4: [
		preload("res://assets/backgrounds/game_background_4/layers/sky.png"),
		preload("res://assets/backgrounds/game_background_4/layers/clouds_1.png"),
		preload("res://assets/backgrounds/game_background_4/layers/clouds_2.png"),
		preload("res://assets/backgrounds/game_background_4/layers/ground.png"),
		preload("res://assets/backgrounds/game_background_4/layers/rocks.png")
	]
}

@export_range(1, 4) var level_number: int = 1
@export var mirror_x: float = 1440.0
@export var sprite_offset: Vector2 = Vector2(0, -540)
@export var sprite_scale: Vector2 = Vector2(0.75, 0.75)

func _ready() -> void:
	add_backgrounds()

func get_increment() -> float:
	return 1.0 / BG_FILES[level_number].size()
	
func get_sprite(t: Texture2D) -> Sprite2D:
	var sprite = Sprite2D.new()
	sprite.texture = t
	sprite.scale = sprite_scale
	sprite.offset = sprite_offset
	return sprite

func add_layer(t: Texture2D, time_offset: float):
	var sprite = get_sprite(t)
	
	var par_la = ParallaxLayer.new()
	par_la.motion_mirroring = Vector2(mirror_x, 0)
	par_la.motion_scale = Vector2(time_offset, 1)
	par_la.add_child(sprite)
	
	add_child(par_la)

func add_backgrounds():
	var inc = get_increment()
	var time_offset = inc
	var files_list = BG_FILES[level_number]
	
	for index in range(files_list.size()):
		var bg_file = files_list[index]
		if index == 0:
			add_layer(bg_file, 1)
		else:
			add_layer(bg_file, time_offset)
			time_offset += inc

var BG_FILES = {
	1: [
		// 各背景レイヤーのテクスチャファイルを事前にロード(preload)しています
		preload("res://assets/backgrounds/game_background_1/layers/sky.png"),
		preload("res://assets/backgrounds/game_background_1/layers/clouds_1.png"),
		// 省略
	],
	// 他のレベルも同様に定義されています
}

@export_range(1, 4) var level_number: int = 1
@export var mirror_x: float = 1440.0
@export var sprite_offset: Vector2 = Vector2(0, -540)
@export var sprite_scale: Vector2 = Vector2(0.75, 0.75)

func _ready() -> void:
	add_backgrounds()

func get_increment() -> float:
	return 1.0 / BG_FILES[level_number].size()

func get_sprite(t: Texture2D) -> Sprite2D:
	var sprite = Sprite2D.new()
	sprite.texture = t
	sprite.scale = sprite_scale
	sprite.offset = sprite_offset
	return sprite

func add_layer(t: Texture2D, time_offset: float):
	var sprite = get_sprite(t)
	
	var par_la = ParallaxLayer.new()
	par_la.motion_mirroring = Vector2(mirror_x, 0)
	par_la.motion_scale = Vector2(time_offset, 1)
	par_la.add_child(sprite)
	
	add_child(par_la)

func add_backgrounds():
	var inc = get_increment()
	var time_offset = inc
	var files_list = BG_FILES[level_number]
	
	for index in range(files_list.size()):
		var bg_file = files_list[index]
		if index == 0:
			add_layer(bg_file, 1)
		else:
			add_layer(bg_file, time_offset)
			time_offset += inc

extends Node2D

@onready var player_cam: Camera2D = $PlayerCam
@onready var player: CharacterBody2D = $Player

func _ready() -> void:
	#Engine.time_scale = 1
	get_tree().paused = false

func _physics_process(delta: float) -> void:
	player_cam.position = player.position

extends Camera2D

@onready var shake_timer: Timer = $ShakeTimer

@export var shake_amount: float = 5.0

func _ready() -> void:
	set_process(false)
	SignalManager.on_player_hit.connect(on_player_hit)

func _process(delta: float) -> void:
	offset = get_random_offset()

func get_random_offset():
	return Vector2(
		randf_range(-shake_amount, shake_amount),
		randf_range(-shake_amount, shake_amount),
	)

func shake():
	set_process(true)
	shake_timer.start()

func on_player_hit(_lives: int):
	shake()
	

func _on_shake_timer_timeout() -> void:
	set_process(false)
	offset = Vector2.ZERO

extends Node

signal on_enemy_hit(points: int, enemy_position: Vector2)
signal on_pickup_hit(points: int)
signal on_boss_killed(points: int)
signal on_player_hit(lives: int)
signal on_level_complete
signal on_game_over
signal on_score_updated

func reduce_lives():
	_lives -= 1
	SignalManager.on_player_hit.emit(_lives)
	if _lives <= 0:
		SignalManager.on_game_over.emit()
		set_physics_process(false)
		return false
	return true

func _ready() -> void:
	_hearts = hb_hearts.get_children()
	SignalManager.on_level_complete.connect(on_level_complete)
	SignalManager.on_game_over.connect(on_game_over)
	SignalManager.on_player_hit.connect(on_player_hit)
	SignalManager.on_score_updated.connect(on_score_updated)

func on_game_over():
	vb_game_over.visible = true
	show_hud()

extends Control

@onready var color_rect: ColorRect = $ColorRect
@onready var vb_level_complete: VBoxContainer = $ColorRect/VB_LevelComplete
@onready var vb_game_over: VBoxContainer = $ColorRect/VB_GameOver
@onready var hb_hearts: HBoxContainer = $MC/HB/HB_Hearts
@onready var score_label: Label = $MC/HB/ScoreLabel

var _hearts: Array

func _ready() -> void:
	_hearts = hb_hearts.get_children()
	SignalManager.on_level_complete.connect(on_level_complete)
	SignalManager.on_game_over.connect(on_game_over)
	SignalManager.on_player_hit.connect(on_player_hit)
	SignalManager.on_score_updated.connect(on_score_updated)

func _process(delta: float) -> void:
	if vb_level_complete.visible:
		if Input.is_action_just_pressed("jump"):
			GameManager.load_next_level_scene()
	if vb_game_over.visible:
		if Input.is_action_just_pressed("jump"):
			GameManager.load_main_scene()

func show_hud():
	#Engine.time_scale = 0
	get_tree().paused = true
	color_rect.visible = true

func on_score_updated():
	score_label.text = str(ScoreManager.get_score()).lpad(5, "0")

func on_player_hit(lives: int):
	for life in range(_hearts.size()):
		_hearts[life].visible = lives > life
	

func on_game_over():
	vb_game_over.visible = true
	show_hud()
	
func on_level_complete():
	vb_level_complete.visible = true
	show_hud()

{
  "1": {
    "tiles": {
      "Floor": [
        {
          "coord": {
            "x": 6,
            "y": 3
          }
        }
      ],
      "Walls": [
        {
          "coord": {
            "x": 6,
            "y": 3
          }
        },
      ],
      "Targets": [
        {
          "coord": {
            "x": 7,
            "y": 4
          }
        },
      ],
      "TargetBoxes": [],
      "Boxes": [
        {
          "coord": {
            "x": 7,
            "y": 6
          }
        }
      ]
    },
    "player_start": {
      "x": 8,
      "y": 7
    }
  },
}

extends Node

const LEVEL_DATA_PATH: String = "res://data/level_data.json"
const TILE_SIZE: int = 32

var _level_data: Dictionary = {}

func _ready() -> void:
	load_level_data()

func load_level_data():
	var file = FileAccess.open(LEVEL_DATA_PATH, FileAccess.READ)
	_level_data = JSON.parse_string(file.get_as_text())
	
func get_data_for_level(level_num: String) -> Dictionary:
	return _level_data[level_num]

extends Node2D

@onready var tile_map: TileMap = $TileMap
@onready var player: AnimatedSprite2D = $Player
@onready var camera_2d: Camera2D = $Camera2D

const FLOOR_LAYER = 0
const WALL_LAYER = 1
const TARGET_LAYER = 2
const BOX_LAYER = 3

const SOURCE_ID = 0

const LAYER_KEY_FLOOR = "Floor"
const LAYER_KEY_WALLS = "Walls"
const LAYER_KEY_TARGETS = "Targets"
const LAYER_KEY_TARGET_BOXES = "TargetBoxes"
const LAYER_KEY_BOXES = "Boxes"

const LAYER_MAP = {
	LAYER_KEY_FLOOR: FLOOR_LAYER,
	LAYER_KEY_WALLS: WALL_LAYER,
	LAYER_KEY_TARGETS: TARGET_LAYER,
	LAYER_KEY_TARGET_BOXES: BOX_LAYER,
	LAYER_KEY_BOXES: BOX_LAYER
}

func _ready() -> void:
	setup_level()

func get_atlas_coord_for_layer_name(layer_name: String) -> Vector2i:
	match layer_name:
		LAYER_KEY_FLOOR:
			return Vector2i(randi_range(3, 8), 0)
		LAYER_KEY_WALLS:
			return Vector2i(2, 0)
		LAYER_KEY_TARGETS:
			return Vector2i(9, 0)
		LAYER_KEY_TARGET_BOXES:
			return Vector2i(0, 0)
		LAYER_KEY_BOXES:
			return Vector2i(1, 0)
	return Vector2i.ZERO

func add_tile(tile_coord: Dictionary, layer_name: String):
	var layer_number = LAYER_MAP[layer_name]
	var coord_vec: Vector2i = Vector2i(tile_coord.x, tile_coord.y)
	var atlas_vec = get_atlas_coord_for_layer_name(layer_name)
	
	tile_map.set_cell(layer_number, coord_vec, SOURCE_ID, atlas_vec)

func add_layer_tiles(layer_tiles, layer_name: String):
	for tile_coord in layer_tiles:
		add_tile(tile_coord.coord, layer_name)

func setup_level():
	tile_map.clear()
	var level_data = GameData.get_data_for_level("24")
	var level_tiles = level_data.tiles
	var player_start = level_data.player_start
	
	for layer_name in LAYER_MAP.keys():
		add_layer_tiles(level_tiles[layer_name], layer_name)

extends Node

const SCORE_FILE: String = "user://scores.dat"
const NO_BEST: int = 10000

var _best_scores: Dictionary = {}

func _ready() -> void:
	load_scores()

func load_scores():
	if !FileAccess.file_exists(SCORE_FILE):
		return
	var file = FileAccess.open(SCORE_FILE, FileAccess.READ)
	_best_scores = JSON.parse_string(file.get_as_text())

func save_scores():
	var file = FileAccess.open(SCORE_FILE, FileAccess.WRITE)
	file.store_string(JSON.stringify(_best_scores))

func has_level_score(level: String):
	return level in _best_scores

func get_level_best_scores(level: String):
	if has_level_score(level):
		return _best_scores[level]
	return NO_BEST

func score_in_new_best(level: String, moves: int):
	if !has_level_score(level):
		return true
	if get_level_best_scores(level) > moves:
		return true
	return false

func level_completed(level: String, moves: int):
	if score_in_new_best(level, moves):
		_best_scores[level] = moves
	save_scores()

func check_game_state():
	for t in tile_map.get_used_cells(TARGET_LAYER):
		if !cell_is_box(t):
			return
	
	game_over_ui.show()
	hud.hide()
	ScoreSync.level_completed(GameManager.get_level_selected(), _total_moves)

extends Node2D

const ANIM_FRAMES = {
	GameData.ENEMY_TYPE.ZIPPER: ["zipper_1", "zipper_2", "zipper_3"],
	GameData.ENEMY_TYPE.BIO: ["biomech_1", "biomech_2", "biomech_3"],
	GameData.ENEMY_TYPE.BOMBER: ["bomber_1", "bomber_2", "bomber_3"],
}

const ENEMY_SCENES = {
	GameData.ENEMY_TYPE.ZIPPER: preload("res://scenes/enemies/enemy_zipper.tscn"),
	GameData.ENEMY_TYPE.BIO: preload("res://scenes/enemies/enemy_bio.tscn"),
	GameData.ENEMY_TYPE.BOMBER: preload("res://scenes/enemies/enemy_bomber.tscn"),
}

@onready var paths: Node2D = $Paths

var _paths_list: Array = []

func _ready() -> void:
	_paths_list = paths.get_children()
	spawn_wave()
	
func create_enemy(speed: float, anim_name: String, en_type: GameData.ENEMY_TYPE):
	var new_en = ENEMY_SCENES[en_type].instantiate()
	new_en.setup(speed, anim_name)
	return new_en

func spawn_wave():
	var path = _paths_list.pick_random()
	var en_type = GameData.ENEMY_TYPE.values().pick_random()
	var anim = ANIM_FRAMES[en_type].pick_random()
	
	for num in range(4):
		path.add_child(create_enemy(0.2, anim, en_type))
		await get_tree().create_timer(1).timeout

func _on_spawn_timer_timeout() -> void:
	spawn_wave()

extends Node2D


const ANIM_FRAMES = {
	GameData.ENEMY_TYPE.ZIPPER: ["zipper_1", "zipper_2", "zipper_3"],
	GameData.ENEMY_TYPE.BIO: ["biomech_1", "biomech_2", "biomech_3"],
	GameData.ENEMY_TYPE.BOMBER: ["bomber_1", "bomber_2", "bomber_3"],
}

const ENEMY_SCENES = {
	GameData.ENEMY_TYPE.ZIPPER: preload("res://scenes/enemies/enemy_zipper.tscn"),
	GameData.ENEMY_TYPE.BIO: preload("res://scenes/enemies/enemy_bio.tscn"),
	GameData.ENEMY_TYPE.BOMBER: preload("res://scenes/enemies/enemy_bomber.tscn")
}

const ENEMY_DATA = {
	GameData.ENEMY_TYPE.ZIPPER: { "speed": 0.10, "gap": 0.6, "min": 6, "max": 10},
	GameData.ENEMY_TYPE.BIO:  { "speed": 0.08, "gap": 0.7, "min": 6, "max": 8},
	GameData.ENEMY_TYPE.BOMBER: { "speed": 0.07, "gap": 1.0, "min": 2, "max": 4},
}

@onready var paths = $Paths
@onready var spawn_timer = $SpawnTimer


var _paths_list: Array = []
var _speed_factor: float = 1.0
var _wave_count: int = 0
var _last_path_index: int = -1
var _wave_gap: float = 6.0

# Called when the node enters the scene tree for the first time.
func _ready():
	_paths_list = paths.get_children()
	print(len(_paths_list))
	spawn_wave()


func create_enemy(speed: float, anim_name:String, en_type: GameData.ENEMY_TYPE):
	var new_en = ENEMY_SCENES[en_type].instantiate()
	new_en.setup(speed, anim_name)
	return new_en
	

func update_speeds() -> void:
	if _wave_count % len(_paths_list) == 0 and _wave_count != 0:
		_speed_factor *= 1.05
		_wave_gap *= 0.97
		print("update_speeds(): _wave_count:%s _speed_factor:%s _wave_gap:%s" % [
			_wave_count, _speed_factor, _wave_gap])
		
		
func start_spawn_timer() -> void:
	spawn_timer.wait_time = _wave_gap
	spawn_timer.start()
	

func get_random_path_index() -> int:
	var index = randi_range(0, len(_paths_list)-1)
	while index == _last_path_index:
		index = randi_range(0, len(_paths_list)-1)
	_last_path_index = index
	return index


func spawn_wave() -> void:
	var path = _paths_list[get_random_path_index()]
	var en_type = GameData.ENEMY_TYPE.values().pick_random()
	var anim = ANIM_FRAMES[en_type].pick_random()	
	var spawn_data = ENEMY_DATA[en_type]
	
	print("\nspawn_wave()\n_last_path_index:", _last_path_index)
	print("spawn_data:", spawn_data)
	
	for num in range(randi_range(spawn_data.min, spawn_data.max)):
		path.add_child(create_enemy(spawn_data.speed * _speed_factor, anim, en_type))
		await get_tree().create_timer(spawn_data.gap).timeout
	
	print("wave() spawned, waiting:", _wave_gap)
	_wave_count += 1
	await get_tree().create_timer(_wave_gap).timeout
	update_speeds()
	start_spawn_timer()


func _on_spawn_timer_timeout():
	spawn_wave()

func _ready():
	_paths_list = paths.get_children()
	print(len(_paths_list))
	spawn_wave()

func create_enemy(speed: float, anim_name: String, en_type: GameData.ENEMY_TYPE):
	var new_en = ENEMY_SCENES[en_type].instantiate()
	new_en.setup(speed, anim_name)
	return new_en

func update_speeds() -> void:
	if _wave_count % len(_paths_list) == 0 and _wave_count != 0:
		_speed_factor *= 1.05
		_wave_gap *= 0.97
		print("update_speeds(): _wave_count:%s _speed_factor:%s _wave_gap:%s" % [
			_wave_count, _speed_factor, _wave_gap])

func start_spawn_timer() -> void:
	spawn_timer.wait_time = _wave_gap
	spawn_timer.start()

func get_random_path_index() -> int:
	var index = randi_range(0, len(_paths_list) - 1)
	while index == _last_path_index:
		index = randi_range(0, len(_paths_list) - 1)
	_last_path_index = index
	return index

func spawn_wave() -> void:
	var path = _paths_list[get_random_path_index()]
	var en_type = GameData.ENEMY_TYPE.values().pick_random()
	var anim = ANIM_FRAMES[en_type].pick_random()	
	var spawn_data = ENEMY_DATA[en_type]
	
	print("\nspawn_wave()\n_last_path_index:", _last_path_index)
	print("spawn_data:", spawn_data)
	
	for num in range(randi_range(spawn_data.min, spawn_data.max)):
		path.add_child(create_enemy(spawn_data.speed * _speed_factor, anim, en_type))
		await get_tree().create_timer(spawn_data.gap).timeout
	
	print("wave() spawned, waiting:", _wave_gap)
	_wave_count += 1
	await get_tree().create_timer(_wave_gap).timeout
	update_speeds()
	start_spawn_timer()

func _on_spawn_timer_timeout():
	spawn_wave()

extends Area2D

var _direction: Vector2 = Vector2.UP
var _speed: float = 200.0
var _damage: int = 10


func _process(delta: float) -> void:
	position += _direction * _speed * delta
	
func setup(pos: Vector2, dir: Vector2, sp: float, dmg: int):
	_direction = dir
	_speed = sp
	_damage = dmg
	global_position = pos
	
func blow_up(area: Node2D):
	pass


func _on_visible_on_screen_notifier_2d_screen_exited() -> void:
	queue_free()


func _on_area_entered(area: Area2D) -> void:
	blow_up(area)

extends Area2D
class_name Player

@onready var sprite_2d: Sprite2D = $Sprite2D
@onready var animation_player: AnimationPlayer = $AnimationPlayer

@export var bullet_scene: PackedScene
@export var speed: float = 250.0
@export var bullet_speed: float = 250.0
@export var bullet_damage: int = 10
@export var bullet_direction: Vector2 = Vector2.UP

const MARGIN: float = 32.0

var _upper_left: Vector2
var _lower_right: Vector2

func _ready() -> void:
	var vp = get_viewport_rect()
	_lower_right = Vector2(
		vp.size.x - MARGIN,
		vp.size.y - MARGIN
	)
	_upper_left = Vector2(MARGIN, MARGIN)

func _process(delta: float) -> void:
	var input = get_input()
	
	global_position += input * delta * speed
	global_position = global_position.clamp(
		_upper_left,
		_lower_right
	)
	
	if Input.is_action_just_pressed("shoot"):
		shoot()

func get_input() -> Vector2:
	var v = Vector2(
		Input.get_axis("left", "right"),
		Input.get_axis("up", "down")
	)
	
	if  v.x != 0:
		animation_player.play("turn")
		if v.x > 0:
			sprite_2d.flip_h = true
		else:
			sprite_2d.flip_h = false
	else:
		animation_player.play("fly")
		
	return v.normalized()
	
func shoot():
	var bullet = bullet_scene.instantiate()
	bullet.setup(
		global_position,
		bullet_direction,
		bullet_speed,
		bullet_damage
	)
	get_tree().root.add_child(bullet)

extends Area2D

const ROTATION_SPEED: float = 200.0
const SPEED: float = 100.0

var _player_ref: Player

func _ready() -> void:
	_player_ref = get_tree().get_first_node_in_group(GameData.GROUP_PLAYER)

func _process(delta: float) -> void:
	turn(delta)
	position += transform.x.normalized() * SPEED * delta

func get_angle_to_player():
	if !is_instance_valid(_player_ref):
		return 0.0
		
	return rad_to_deg((_player_ref.global_position - global_position).angle())
	
func get_angle_to_turn(angle_to_player: float):
	return fmod((angle_to_player - global_rotation_degrees + 180.0), 360.0) - 180.0
	
func turn(delta: float):
	var angle_to_player = get_angle_to_player()
	var angle_to_turn = get_angle_to_turn(angle_to_player)
	
	if abs(angle_to_turn) < 180.0:
		rotation_degrees += sign(angle_to_turn) * delta * ROTATION_SPEED
	else:
		rotation_degrees += sign(angle_to_turn) * -1 * delta * ROTATION_SPEED

func _ready() -> void:
	_player_ref = get_tree().get_first_node_in_group(GameData.GROUP_PLAYER)

func _process(delta: float) -> void:
	turn(delta)
	position += transform.x.normalized() * SPEED * delta

func get_angle_to_player():
	if !is_instance_valid(_player_ref):
		return 0.0
		
	return rad_to_deg((_player_ref.global_position - global_position).angle())

func get_angle_to_turn(angle_to_player: float):
	return fmod((angle_to_player - global_rotation_degrees + 180.0), 360.0) - 180.0

func turn(delta: float):
	var angle_to_player = get_angle_to_player()
	var angle_to_turn = get_angle_to_turn(angle_to_player)
	
	if abs(angle_to_turn) < 180.0:
		rotation_degrees += sign(angle_to_turn) * delta * ROTATION_SPEED
	else:
		rotation_degrees += sign(angle_to_turn) * -1 * delta * ROTATION_SPEED

extends Camera2D

@onready var timer: Timer = $Timer

const SHAKE_RANGE: Vector2 = Vector2(-3.0, 3.0)
var _shake_offset: Vector2 = Vector2.ZERO

func _ready() -> void:
	_shake_offset = offset
	SignalManager.on_player_hit.connect(on_player_hit)
	set_process(false)

func _process(delta: float) -> void:
	offset = Vector2(
		_shake_offset.x + get_random_shake_amount(),
		_shake_offset.y + get_random_shake_amount()
	)
	
func get_random_shake_amount():
	return randf_range(SHAKE_RANGE.x, SHAKE_RANGE.y)

func on_player_hit(_v: int):
	set_process(true)
	timer.start()
	
	

func _on_timer_timeout() -> void:
	set_process(false)
	offset = _shake_offset

extends Resource
class_name WaveResource

@export var enemy_type: GameData.ENEMY_TYPE
@export var speed: float
@export var gap: float
@export var min: float
@export var max: float

extends Resource
class_name WaveListResource

@export var waves: Array[WaveResource]
@export var wave_gap: float
@export var speed_factor: float

var _current_wave: int = 0

func get_next_wave() -> WaveResource:
	if _current_wave == waves.size():
		_current_wave = 0
	
	var index = _current_wave
	_current_wave += 1
	
	return waves[index]

extends Node2D

var wave_list: WaveListResource = preload("res://wave_resources/wave_list.tres")

const ANIM_FRAMES = {
	GameData.ENEMY_TYPE.ZIPPER: ["zipper_1", "zipper_2", "zipper_3"],
	GameData.ENEMY_TYPE.BIO: ["biomech_1", "biomech_2", "biomech_3"],
	GameData.ENEMY_TYPE.BOMBER: ["bomber_1", "bomber_2", "bomber_3"],
}

const ENEMY_SCENES = {
	GameData.ENEMY_TYPE.ZIPPER: preload("res://scenes/enemies/enemy_zipper.tscn"),
	GameData.ENEMY_TYPE.BIO: preload("res://scenes/enemies/enemy_bio.tscn"),
	GameData.ENEMY_TYPE.BOMBER: preload("res://scenes/enemies/enemy_bomber.tscn")
}


@onready var paths = $Paths
@onready var spawn_timer = $SpawnTimer


var _paths_list: Array = []
var _wave_count: int = 0
var _last_path_index: int = -1

# Called when the node enters the scene tree for the first time.
func _ready():
	_paths_list = paths.get_children()
	print(len(_paths_list))
	spawn_wave()


func create_enemy(speed: float, anim_name:String, en_type: GameData.ENEMY_TYPE):
	var new_en = ENEMY_SCENES[en_type].instantiate()
	new_en.setup(speed, anim_name)
	return new_en
	

func update_speeds() -> void:
	if _wave_count % len(_paths_list) == 0 and _wave_count != 0:
		wave_list.speed_factor *= 1.05
		wave_list.wave_gap *= 0.97
		print("update_speeds(): _wave_count:%s _speed_factor:%s _wave_gap:%s" % [
			_wave_count, wave_list.speed_factor, wave_list.wave_gap])
		
		
func start_spawn_timer() -> void:
	spawn_timer.wait_time = wave_list.wave_gap
	spawn_timer.start()
	

func get_random_path_index() -> int:
	var index = randi_range(0, len(_paths_list)-1)
	while index == _last_path_index:
		index = randi_range(0, len(_paths_list)-1)
	_last_path_index = index
	return index


func spawn_wave() -> void:
	var path = _paths_list[get_random_path_index()]
	
	var wave_res: WaveResource = wave_list.get_next_wave()

	var en_type = wave_res.enemy_type
	var anim = ANIM_FRAMES[en_type].pick_random()
	
	print("\nspawn_wave()\n_last_path_index:", _last_path_index)
	print("wave_res:", wave_res)
	
	for num in range(randi_range(wave_res.min, wave_res.max)):
		path.add_child(create_enemy(wave_res.speed * wave_list.speed_factor, anim, en_type))
		await get_tree().create_timer(wave_res.gap).timeout
	
	print("wave() spawned, waiting:", wave_list.wave_gap)
	_wave_count += 1
	await get_tree().create_timer(wave_list.wave_gap).timeout
	update_speeds()
	start_spawn_timer()


func _on_spawn_timer_timeout():
	spawn_wave()

extends Resource
class_name WaveResource

@export var enemy_type: GameData.ENEMY_TYPE
@export var speed: float
@export var gap: float
@export var min: float
@export var max: float

extends Resource
class_name WaveListResource

@export var waves: Array[WaveResource]
@export var wave_gap: float
@export var speed_factor: float

var _current_wave: int = 0

func get_next_wave() -> WaveResource:
	if _current_wave == waves.size():
		_current_wave = 0
	
	var index = _current_wave
	_current_wave += 1
	
	return waves[index]

extends Node2D

var wave_list: WaveListResource = preload("res://wave_resources/wave_list.tres")

const ANIM_FRAMES = {
	GameData.ENEMY_TYPE.ZIPPER: ["zipper_1", "zipper_2", "zipper_3"],
	GameData.ENEMY_TYPE.BIO: ["biomech_1", "biomech_2", "biomech_3"],
	GameData.ENEMY_TYPE.BOMBER: ["bomber_1", "bomber_2", "bomber_3"],
}

const ENEMY_SCENES = {
	GameData.ENEMY_TYPE.ZIPPER: preload("res://scenes/enemies/enemy_zipper.tscn"),
	GameData.ENEMY_TYPE.BIO: preload("res://scenes/enemies/enemy_bio.tscn"),
	GameData.ENEMY_TYPE.BOMBER: preload("res://scenes/enemies/enemy_bomber.tscn")
}

@onready var paths = $Paths
@onready var spawn_timer = $SpawnTimer

var _paths_list: Array = []
var _wave_count: int = 0
var _last_path_index: int = -1

# Called when the node enters the scene tree for the first time.
func _ready():
	_paths_list = paths.get_children()
	print(len(_paths_list))
	spawn_wave()

func create_enemy(speed: float, anim_name: String, en_type: GameData.ENEMY_TYPE):
	var new_en = ENEMY_SCENES[en_type].instantiate()
	new_en.setup(speed, anim_name)
	return new_en

func update_speeds() -> void:
	if _wave_count % len(_paths_list) == 0 and _wave_count != 0:
		wave_list.speed_factor *= 1.05
		wave_list.wave_gap *= 0.97
		print("update_speeds(): _wave_count:%s _speed_factor:%s _wave_gap:%s" % [
			_wave_count, wave_list.speed_factor, wave_list.wave_gap])

func start_spawn_timer() -> void:
	spawn_timer.wait_time = wave_list.wave_gap
	spawn_timer.start()

func get_random_path_index() -> int:
	var index = randi_range(0, len(_paths_list) - 1)
	while index == _last_path_index:
		index = randi_range(0, len(_paths_list) - 1)
	_last_path_index = index
	return index

func spawn_wave() -> void:
	var path = _paths_list[get_random_path_index()]
	var wave_res: WaveResource = wave_list.get_next_wave()
	var en_type = wave_res.enemy_type
	var anim = ANIM_FRAMES[en_type].pick_random()

	print("\nspawn_wave()\n_last_path_index:", _last_path_index)
	print("wave_res:", wave_res)

	for num in range(randi_range(wave_res.min, wave_res.max)):
		path.add_child(create_enemy(wave_res.speed * wave_list.speed_factor, anim, en_type))
		await get_tree().create_timer(wave_res.gap).timeout

	print("wave() spawned, waiting:", wave_list.wave_gap)
	_wave_count += 1
	await get_tree().create_timer(wave_list.wave_gap).timeout
	update_speeds()
	start_spawn_timer()

func _on_spawn_timer_timeout():
	spawn_wave()