fps_project_1/scripts/LevelManager.gd

extends Node3D

@export var load_save : = true
@export var player : Node
@export var money = 250
@export var start_health = 3
@export var MAX_PARTICLES = 100
@export var gun_1 : Resource
@export var gun_2 : Resource
@export_group("Drops")
@export var ammo_drop_enabled = true
@export var stamina_drop_enabled = true
@export var health_drop_enabled = true
@export var money_drop_enabled = true

@onready var crown = preload("res://assets/crown.tscn")
var ammo_drop = [[load("res://assets/ammo_pickup.tscn")],["ammo"]]
var stamina_drop = [[load("res://assets/stamina_pickup.tscn")],["stamina"]]
var health_drop = [[load("res://assets/health_pickup.tscn")],["health"]]
var money_drop = [[load("res://assets/money_pickup.tscn")],["money"]]
var dead_player = preload("res://assets/dead_cam.tscn")
const CLEARED_ANNOUNCE = preload("res://assets/cleared_announce.tscn")
const DEAD_ANNOUNCE = preload("res://assets/dead_announce.tscn")

var paused = false
var health = start_health
var pickups = []
var held_guns = []
var ammo_current = [0]
var ammo_reserve = [0]
var keys = []
var guns_dict = {}
var current_gun_index
var particle_number = 0
var enemy_hiveminds = []
var remaining_enemies
var last_hit : Node
var target_type
var respawn_position
var respawn_cam_rotation
var respawn_rot
var engine_time_scale_cache : float = 1.0

# Called when the node enters the scene tree for the first time.
func _ready():
	#connect to signals
	SignalBus.enemy_count_changed.connect(enemy_count)
	
	#LOAD DATA
	SaveLoad.load_persistent_data()
	
	if SaveLoad.data_cleared or !load_save:
		refresh_scene()
		GameGlobals.game_loaded = true
		SignalBus.emit_signal("game_loaded")
	else:
		SaveLoad.load_save_game_data()
	
	#Spawn Crown
	if SaveLoad.last_hit_path:
		var crown_spawn = crown.instantiate()
		var crown_target = get_node(SaveLoad.last_hit_path)
		if crown_target:
			crown_target.add_child(crown_spawn)
			crown_spawn.position = Vector3(0,2,0)
	#global randomize function
	randomize()
	
	#assign pickups to array
	if ammo_drop_enabled == true:
		pickups.append(ammo_drop)
	if stamina_drop_enabled == true:
		pickups.append(stamina_drop)
	if health_drop_enabled == true:
		pickups.append(health_drop)
	if money_drop_enabled == true:
		pickups.append(money_drop)
		
	#clear spawned in objects
	for node in get_tree().get_nodes_in_group("spawned"):
		node.queue_free()
	
	#find enemy hiveminds
	for node in get_tree().get_nodes_in_group("enemy_hivemind"):
		enemy_hiveminds.append(node)
	#count starting enemies
	enemy_count()

func refresh_scene():
	health = start_health
	
	respawn_position = player.camera.global_position
	respawn_cam_rotation = player.global_transform.basis
	
	if player:
		#Set up starting guns and ammo
		if gun_1 != null:
			held_guns = [gun_1]
			var instance_gun = held_guns[0].instantiate()
			ammo_current[0] = instance_gun.max_ammo
			ammo_reserve[0] = instance_gun.max_ammo * instance_gun.start_mags
		
		if gun_2 != null:
			held_guns.append(gun_2)
			var instance_gun_2 = held_guns[1].instantiate()
			ammo_current.append(instance_gun_2.max_ammo)
			ammo_reserve.append(instance_gun_2.max_ammo * instance_gun_2.start_mags)

		# Spawn first gun
		if gun_1 != null:
			current_gun_index = 0
			gun_spawn(0)
			

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta):
	#quit game and eventually go to menu
	if Input.is_action_just_pressed("escape"):
		pause_menu()
	


func gun_spawn(index):
	
	#loop around if scrolling past available guns
	if index > held_guns.size() - 1:
		index = 0
	elif index < 0:
		index = held_guns.size() - 1
	
	current_gun_index = index
	
	var instance_gun = held_guns[index].instantiate()
	instance_gun.global_transform.origin = player.weapon_spawner.position
	player.gun = instance_gun
	player.def_weapon_holder_pos = player.weapon_holder.position
	player.ammo = player.gun.max_ammo
	player.ammo_reserve = player.gun.max_ammo * player.gun.start_mags
	#player.gun_fire_pitch_starting = player.gun.audio_fire.pitch_scale
	instance_gun.gun_index = index
	instance_gun.anim_player.play("swap_in")
	player.weapon_holder.add_child(instance_gun)

func enemy_count():
	var sum = 0
	var enemies = get_tree().get_nodes_in_group("enemy")
	for i in enemies:
		if i.get_class() == "CharacterBody3D":
			sum += 1
	print("enemies: " + str(sum))
	if sum == 0:
		cleared()

func cleared():
	var clearedmsg = CLEARED_ANNOUNCE.instantiate()
	get_parent().add_child(clearedmsg)
	await get_tree().create_timer(1).timeout
	clearedmsg.queue_free()

func die():
	#record stats
	if SaveLoad.player_deaths:
		SaveLoad.player_deaths += 1
	else:
		SaveLoad.player_deaths = 1
	SaveLoad.save_persistent_data()
	SaveLoad.clear_save_game_data()
	var deadmsg = DEAD_ANNOUNCE.instantiate()
	get_parent().add_child(deadmsg)
	var instance_dead = dead_player.instantiate()
	instance_dead.global_position = player.camera.global_position
	instance_dead.transform.basis = player.global_transform.basis
	if last_hit != null:
		instance_dead.target = last_hit
		SaveLoad.last_hit_path = str(last_hit.get_path())
	instance_dead.target_type = target_type
	instance_dead.respawn_position = respawn_position
	instance_dead.respawn_rotation = respawn_cam_rotation
	instance_dead.respawn_fov = player.camera.fov
	get_tree().get_root().add_child(instance_dead)
	instance_dead.camera.current = true
	player.dead = true
	player.toggle_hud(true)
	player.gun.visible = false
	player.health_indicator.color = Color(0.471, 0, 0, 0)
	player.crosshair.visible = false


func pickup_spawn():
	var item_type = pickups.pick_random()
	var item_spawn = item_type[0][0].instantiate()
	#var item_name = item_type[1][0]
	item_spawn.rand_amt = randi_range(25,100)
	return item_spawn

func pause_menu():
	if paused:
		Engine.time_scale = engine_time_scale_cache
		Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
		player.toggle_hud(true)
		player.pause_menu.hide()
	else:
		engine_time_scale_cache = Engine.time_scale
		Engine.time_scale = 0
		Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
		player.toggle_hud(false)
		player.pause_menu.show()
	
	paused = !paused

func save_quit():
	SaveLoad.save_game_data()
	get_tree().quit()