DashBoomColorClash/scenes/World.gd

class_name World extends Node3D

var players: Array

@onready var score_update_timer: Timer = $ScoreUpdateTimer
@onready var pixel_count_compute_shader: PixelCountComputeShader = $PixelCountComputeShader

@onready var camera: Camera3D = $Camera3D
@onready var level: Node3D = $Level
@onready var world_coloring_viewport: SubViewport = $WorldColoringViewport
@onready var music_stream_player: AudioStreamPlayer = $MusicAudioStreamPlayer

var player_scene = preload("res://entities/Player.tscn")
var player_override_material = preload("res://materials/PlayerMaterial.tres")

var level_scenes : Array = [
	preload("res://levels/BasicLevel.tscn"),
	preload("res://levels/Platforms.tscn"),
	preload("res://levels/LotsaHoles.tscn")
]

var level_index = 0
var last_level_index = -1

const GAME_DURATION_SECONDS = 20

var camera_position: Vector3;
var world_coloring_material: ShaderMaterial
var world_plane: Plane = Plane(Vector3.UP, Vector3.ZERO)
var spawn_points: Array = Array()

enum GameState {
	Startup,
	LevelSelect,
	Running,
	Finished
}

var time_left = GAME_DURATION_SECONDS
var game_state : GameState = GameState.Startup
var game_state_last : GameState = GameState.Finished

# Called when the node enters the scene tree for the first time.
func _ready():
	camera_position = camera.global_position

	score_update_timer.connect("timeout", update_score)

	load_level()

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta):
	if game_state_last != game_state:
		if game_state == GameState.Startup:
			on_game_startup()
		elif game_state == GameState.LevelSelect:
			on_game_level_select()
		elif game_state == GameState.Running:
			on_game_running()
		elif game_state == GameState.Finished:
			on_game_finished()
		game_state_last = game_state
	
	if game_state == GameState.Running:
		time_left -= _delta;
	else:
		return
		
	if time_left <= 0:
		game_state = GameState.Finished
	
	var player1 : Player = players[0]
	var player_center = Vector3.ZERO
	var player_coords_rect : Rect2 = Rect2(
		player1.global_position.x,
		player1.global_position.z,
		0,
		0,
		)
	
	for player: CharacterBody3D in players:
		player_center += player.global_position
		player_coords_rect = player_coords_rect.expand(Vector2(player.global_position.x, player.global_position.z))

	player_center = player_center / players.size()
	player_center.y = 0
	
	var view_width = player_coords_rect.size.x + 10
	var view_height = player_coords_rect.size.y + 15
	var camera_dist = max (view_width, view_height) * 0.5 / sin(deg_to_rad(camera.fov) * 0.5)

	var camera_direction : Vector3 = -camera.basis.z
	camera_position = player_center - camera_direction * camera_dist
	
	camera.global_position = camera_position

func _physics_process(_delta):
	if level_index != last_level_index:
		load_level()
	
	world_coloring_material.set_shader_parameter("world_color_texture", world_coloring_viewport.get_texture())
	
	if game_state != GameState.Running:
		return
	
	for player: Player in players:
		if player.state == Player.PlayerState.Dead:
			var occupied = true
			var spawn_point
			
			while occupied:
				spawn_point = spawn_points.pick_random() as SpawnPoint
				if not spawn_point.is_occupied():
					occupied = false
			
			player.global_position = spawn_point.global_position + Vector3.UP * 2
			player.state = Player.PlayerState.Alive
			spawn_point.near_players.append(player)

func _unhandled_input(event):
	if game_state == GameState.Startup:
		if event.is_action_pressed("ui_accept"):
			game_state = GameState.Running

func load_level():
	print("Loading level " + str(level_scenes[level_index]))

	for node in level.get_children():
		node.queue_free()
	
	var level_instance = level_scenes[level_index].instantiate()
	print("Loaded level " + level_instance.name)
	level.add_child(level_instance)
	
	spawn_points.clear()
	for node in $Players.get_children():
		node.queue_free()
	
	find_spawn_points(level)
	print("Found " + str(spawn_points.size()) + " spawn points.")
	spawn_players()
	apply_world_coloring_recursive(level)
	
	last_level_index = level_index

func find_spawn_points (node: Node3D):
	for child in node.get_children():
		if child.is_queued_for_deletion():
			continue
			
		var spawn_point = child as SpawnPoint
		if spawn_point:
			spawn_points.append(spawn_point)
			
		find_spawn_points(child)

func apply_world_coloring_recursive (node):
	for child in node.get_children():
		var mesh_instance := child as MeshInstance3D
		if mesh_instance:
			assign_world_coloring_pass(mesh_instance)

		apply_world_coloring_recursive(child)

func assign_world_coloring_pass(mesh_instance: MeshInstance3D) -> void:
	var material = mesh_instance.get_active_material(0)
	if not material:
		return

	material.next_pass = world_coloring_material

func update_score():
	pixel_count_compute_shader.recalculate_score()
	
	players[0].score = pixel_count_compute_shader.red_score
	
	if players.size() > 1:
		players[1].score = pixel_count_compute_shader.blue_score

func spawn_players():
	var players_node = $Players
		
	var player1: Player = player_scene.instantiate()
	player1.name = "Red"
	player1.color = Color(1, 0, 0, 1)
	player1.coloring_sprite_path = world_coloring_viewport.get_node("Player1Sprite").get_path()
	player1.coloring_bomb_sprite_path = world_coloring_viewport.get_node("Player1BombSprite").get_path()	
	player1.move_right_action += "_p1"
	player1.move_left_action += "_p1"
	player1.move_up_action += "_p1"
	player1.move_down_action += "_p1"
	player1.dash_action += "_p1"
	player1.bomb_action += "_p1"
	
	var player2: Player = player_scene.instantiate()
	player2.name = "Blue"
	player2.color = Color(0, 0, 1, 1)
	player2.coloring_sprite_path = world_coloring_viewport.get_node("Player2Sprite").get_path()
	player2.coloring_bomb_sprite_path = world_coloring_viewport.get_node("Player2BombSprite").get_path()	
	player2.move_right_action += "_p2"
	player2.move_left_action += "_p2"
	player2.move_up_action += "_p2"
	player2.move_down_action += "_p2"
	player2.dash_action += "_p2"
	player2.bomb_action += "_p2"
	
	players_node.add_child(player1)
	players_node.add_child(player2)
	
	players.clear()
	
	players.append(player1)
	players.append(player2)
	
	var player1_material : StandardMaterial3D = player_override_material.duplicate()
	player1_material.albedo_color = player1.color
	player1.geometry.set_surface_override_material(0, player1_material)
	player1.name = "Red"
	
	var player2_material : StandardMaterial3D = player_override_material.duplicate()
	player2_material.albedo_color = player2.color
	player2.geometry.set_surface_override_material(0, player2_material)
	player2.name = "Blue"
	
	if players.size() == 1:
		world_coloring_material = load("res://materials/WorldColoringMaterialPass.tres")
		world_coloring_material.set_shader_parameter("world_color_texture", world_coloring_viewport.get_texture())
	else:
		world_coloring_material = load("res://materials/WorldColoringMaterialPassVersus.tres")
		world_coloring_material.set_shader_parameter("world_color_texture", world_coloring_viewport.get_texture())
		
	for player: Player in players:
		player.state = player.PlayerState.Dead

func remove_players():
	var players_node = $Players
	
	for player: Player in players_node.get_children():
		player.queue_free()
	
	players.clear()

func on_game_startup():
	print("Switching to startup")
	stop_gameplay()

	music_stream_player.stop()

	world_coloring_viewport.render_target_clear_mode = SubViewport.CLEAR_MODE_ONCE
	world_coloring_viewport.render_target_update_mode = SubViewport.UPDATE_ONCE

func on_game_level_select():
	print("Switching to level select")
	stop_gameplay()

	music_stream_player.stop()

	world_coloring_viewport.render_target_clear_mode = SubViewport.CLEAR_MODE_ONCE
	world_coloring_viewport.render_target_update_mode = SubViewport.UPDATE_ONCE

func on_game_running():
	print("Switching to gameplay")	
	start_gameplay()
	
	music_stream_player.play()
	
	world_coloring_viewport.render_target_clear_mode = SubViewport.CLEAR_MODE_NEVER
	world_coloring_viewport.render_target_update_mode = SubViewport.UPDATE_ALWAYS

func on_game_finished():
	print("Switching to finished")		
	stop_gameplay()
		
	world_coloring_viewport.render_target_clear_mode = SubViewport.CLEAR_MODE_NEVER
	world_coloring_viewport.render_target_update_mode = SubViewport.UPDATE_ONCE

func stop_gameplay():
	print("Stopping gameplay")
	for player: Player in players:
		player.coloring_sprite.visible = false
		player.coloring_bomb_sprite.visible = false
		player.set_process(false)
		player.set_process_input(false)
		player.set_physics_process(false)
		
func start_gameplay():
	print("Starting gameplay")
	time_left = GAME_DURATION_SECONDS
	
	for player: Player in players:
		player.energy = 100;
		player.coloring_sprite.visible = true
		player.coloring_bomb_sprite.visible = false
		player.set_process(true)
		player.set_process_input(true)
		player.set_physics_process(true)
		player.state = Player.PlayerState.Dead