298 lines
8.7 KiB
GDScript
298 lines
8.7 KiB
GDScript
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
|