Vaillant Jeremy
60d9f614ee
Two of the five autoloads were stateless helper bundles, not the
persistent application-wide systems that the Godot 4 best-practice
guide reserves autoload slots for. Convert them to plain classes with
all-static methods so they no longer need a Node living under /root.
- scripts/Animation.gd -> scripts/game_animation.gd (renamed:
conflict with the built-in Animation class; the autoload sidestepped
it by being called GlobalAnimation). class_name GameAnimation,
every helper static. The dissolve tween now captures its target
material in a lambda closure, eliminating the current_material
member that the autoload kept as shared mutable state.
- scripts/Event.gd -> scripts/event.gd, class_name Event, every
handler static. Added Event.level_pressed(name) -> Callable for the
one place ChooseScene needed dynamic lookup of a per-level handler
(replaces the old _build_method('_on_' + name + '_pressed') +
Callable(autoload, string) reflection trick with an explicit match).
Updated call sites:
- scripts/Global.gd: animation.connect('animation_started',
Callable(Event, '...')) -> animation.animation_started.connect(
Event._loading_is_started). Same for animation_finished.
- scenes/levels/Levels.gd: GlobalAnimation.* -> GameAnimation.*;
Quit/TextureButton.connect('pressed', Callable(Event, '...')) ->
pressed.connect(Event._on_main_scene_pressed).
- scenes/UI/choose_scenes/ChooseScene.gd: per-level button connects
go through Event.level_pressed(); reset button's bound callable now
reads Event._on_reset_level.bind(...); cleanup no longer relies on
is_connected with an unbound Callable (which would never match a
bound one anyway) -- iterates reset.pressed.get_connections()
instead. Drop the now-dead _build_method helper.
Also: organise scripts/ by promoting the one-shot migration helpers
(migrate_shaders, migrate_misc, resave_scenes, devisualize_shaders,
find_visualshaders) into scripts/migration/. They are not part of
the runtime and should not be browsable next to the autoloads.
Autoload count goes 5 -> 3 (Loading, Global, Setting remain --
Setting will move to a Resource in a later refactor).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
277 lines
8.9 KiB
GDScript
277 lines
8.9 KiB
GDScript
extends Node3D
|
|
|
|
const TIME_MAX = 3000 # msec
|
|
const GYROSCOPE_MAX_DIFF = 0.5
|
|
const OFFSET_CAMERA_MAX = 0.12
|
|
const OFFSET_STEP_CHANGE = 0.01
|
|
const RAY_LENGTH = 1000
|
|
|
|
@export var object_first: PackedScene = load("res://scenes/levels/parts/ObjectListFirst.tscn")
|
|
@export var object_std: PackedScene = load("res://scenes/levels/parts/ObjectListStandard.tscn")
|
|
@export var object_last: PackedScene = load("res://scenes/levels/parts/ObjectListLast.tscn")
|
|
|
|
@onready var gyroscope_value_old = Vector3(0, 0, 0)
|
|
@onready var table = Global.database.get_table_by_name("scenes")
|
|
@onready var meshes = {}
|
|
@onready var from = null
|
|
@onready var to = null
|
|
@onready var mlevel = load("res://db/MLevel.gd")
|
|
@onready var mscene = load("res://db/MScene.gd")
|
|
@onready var victory_condition = 0
|
|
@onready var victory_progress = 0
|
|
@onready var last_button = null
|
|
@onready var animation_player = null
|
|
|
|
func _ready():
|
|
_load_translations()
|
|
_load_meshes()
|
|
_load_back_button()
|
|
_load_prepare_victory_condition()
|
|
_load_hud_menu()
|
|
_load_ambient_sound()
|
|
|
|
func _load_translations():
|
|
pass
|
|
|
|
func _load_meshes():
|
|
var scene_detail = null
|
|
|
|
for row_index in range(0, table.m_rows_count):
|
|
scene_detail = mscene.new(row_index)
|
|
|
|
if scene_detail.key() != null:
|
|
meshes[scene_detail.key()] = scene_detail
|
|
create_dissolve_mesh(scene_detail.key())
|
|
|
|
func _load_back_button():
|
|
$Quit/TextureButton.pressed.connect(Event._on_main_scene_pressed)
|
|
|
|
func _load_prepare_victory_condition():
|
|
var level = mlevel.new(Global.current_scene_int)
|
|
|
|
victory_condition = level.object_to_find()
|
|
victory_progress = level.object_finding()
|
|
|
|
func _load_hud_menu():
|
|
var counter = 0
|
|
var scene = null
|
|
var label_counter = null
|
|
|
|
for key in meshes:
|
|
scene = meshes[key]
|
|
_create_button_info(scene, counter, label_counter)
|
|
label_counter = scene.label_counter()
|
|
counter = counter + 1
|
|
|
|
func _load_ambient_sound():
|
|
if Setting.get_setting_ambient_sound():
|
|
$AmbientSound.play()
|
|
$AmbientSound.stream_paused = false
|
|
|
|
func _create_button_info(scene, counter, label_counter):
|
|
var button = _search_button_to_use(counter)
|
|
var label_name = scene.label()
|
|
|
|
if label_counter != null and label_counter == scene.label_counter():
|
|
label_name = last_button.get_node("Label").text + " " + str(scene.counter())
|
|
_configure_button_object(last_button, scene, label_name)
|
|
_create_animation_warning(_get_node_animated().get_node("Label"), label_name)
|
|
else:
|
|
$ListObjects/ListContainer.add_child(button)
|
|
_configure_button_object(button, scene, label_name)
|
|
_create_animation_slide(_get_node_animated(), label_name)
|
|
|
|
last_button = button
|
|
|
|
func _get_node_animated():
|
|
return $ListObjects/ListContainer.get_child($ListObjects/ListContainer.get_child_count() - 1 )
|
|
|
|
func _search_button_to_use(counter):
|
|
if counter == 0:
|
|
return object_first.instantiate()
|
|
elif counter == meshes.size() - 1:
|
|
return object_last.instantiate()
|
|
else:
|
|
return object_std.instantiate()
|
|
|
|
func _configure_button_object(button, scene, label):
|
|
button.get_node("Label").set_text(label)
|
|
button.set_meta("animation", label)
|
|
button.set_meta("name", scene.label())
|
|
button.set_meta("counter", scene.counter())
|
|
button.set_meta("counted", 0)
|
|
|
|
func _create_animation_slide(node, p_name):
|
|
_add_animation_to_player(p_name, GameAnimation.level_hud_slide(node))
|
|
|
|
func _create_animation_warning(node, p_name):
|
|
_add_animation_to_player(p_name, GameAnimation.level_hud_warning(node))
|
|
|
|
func _add_animation_to_player(p_name: String, anim: Animation) -> void:
|
|
var player = $ListObjects/AnimationPlayer
|
|
var lib = player.get_animation_library("")
|
|
if lib == null:
|
|
lib = AnimationLibrary.new()
|
|
player.add_animation_library("", lib)
|
|
lib.add_animation(p_name, anim)
|
|
|
|
func _process(_delta):
|
|
_check_dissolve_mesh()
|
|
_check_change_angle_camera()
|
|
_check_victory_condition()
|
|
|
|
func create_dissolve_mesh(key):
|
|
var mesh = _node_to_mesh(key)
|
|
if mesh == null:
|
|
return
|
|
var material = mesh.get_active_material(0)
|
|
if material == null:
|
|
return
|
|
material.set_shader_parameter("dissolve_amount", 0.0)
|
|
|
|
func _check_dissolve_mesh():
|
|
# Event dissolve in object searched by gamer
|
|
for key in meshes:
|
|
if bool(meshes[key].lock()) == true and meshes[key].mesh() != null:
|
|
var mesh = _node_to_mesh(key)
|
|
if mesh == null:
|
|
continue
|
|
if meshes[key].tick_reference() == 0:
|
|
meshes[key].set_tick_reference(Time.get_ticks_msec())
|
|
_node_object_list(key)
|
|
GameAnimation.start_dissolve(mesh, mesh.get_active_material(0))
|
|
|
|
if Time.get_ticks_msec() < meshes[key].tick_reference() + TIME_MAX:
|
|
meshes[key].set_value(meshes[key].value() + 0.01)
|
|
else:
|
|
_clean_mesh(key)
|
|
|
|
func _clean_mesh(key):
|
|
victory_progress = mlevel.new(Global.current_scene_int).object_finding()
|
|
_node_to_mesh(key).call_deferred("free")
|
|
meshes[key].set_mesh(null)
|
|
|
|
func _check_change_angle_camera():
|
|
var camera = $"MainCamera"
|
|
var gyroscope = Input.get_gyroscope()
|
|
|
|
if camera.h_offset >= -OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_left") or _action_gyroscope("left", gyroscope):
|
|
print("[warcraft#_ready] move camera angle to left")
|
|
$"Main Camera3D".h_offset -= OFFSET_STEP_CHANGE
|
|
|
|
if camera.h_offset <= OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_right") or _action_gyroscope("right", gyroscope):
|
|
print("[warcraft#_ready] move camera angle to right")
|
|
$"Main Camera3D".h_offset += OFFSET_STEP_CHANGE
|
|
|
|
if camera.v_offset >= -OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_down") or _action_gyroscope("down", gyroscope):
|
|
print("[warcraft#_ready] move camera angle to down")
|
|
$"Main Camera3D".v_offset -= OFFSET_STEP_CHANGE
|
|
|
|
if camera.v_offset <= OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_up") or _action_gyroscope("up", gyroscope):
|
|
print("[warcraft#_ready] move camera angle to up")
|
|
$"Main Camera3D".v_offset += OFFSET_STEP_CHANGE
|
|
|
|
gyroscope_value_old = gyroscope
|
|
|
|
func _action_pressed(action):
|
|
return Input.is_action_pressed(action)
|
|
|
|
func _action_gyroscope(action, gyroscope):
|
|
if Setting.get_setting_gyrosocpe():
|
|
var expression = Expression.new()
|
|
|
|
expression.parse("_gyroscope_changed_"+action+"(gyroscope)", ["gyroscope"])
|
|
|
|
if expression.execute([gyroscope], self):
|
|
return true
|
|
else:
|
|
return false
|
|
else:
|
|
return false
|
|
|
|
func _gyroscope_changed_left(gyroscope):
|
|
return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.y < gyroscope_value_old.y
|
|
|
|
func _gyroscope_changed_right(gyroscope):
|
|
return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.y > gyroscope_value_old.y
|
|
|
|
func _gyroscope_changed_down(gyroscope):
|
|
return (gyroscope.abs().z - gyroscope_value_old.abs().z) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.z > gyroscope_value_old.z or \
|
|
(gyroscope.abs().x - gyroscope_value_old.abs().x) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.x > gyroscope_value_old.x
|
|
|
|
func _gyroscope_changed_up(gyroscope):
|
|
return (gyroscope.abs().z - gyroscope_value_old.abs().z) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.z < gyroscope_value_old.z or \
|
|
(gyroscope.abs().x - gyroscope_value_old.abs().x) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.x < gyroscope_value_old.x
|
|
|
|
func _start_dissolve(key):
|
|
if bool(meshes[key].lock()) == false:
|
|
meshes[key].set_lock(int(true))
|
|
$ObjectFind.stream = meshes[key].audio_sound()
|
|
$ObjectFind.play()
|
|
|
|
func _check_victory_condition():
|
|
if victory_condition == victory_progress:
|
|
print("[levels#_check_victory_condition] \\o/\\o/ \\o/ \\o/ \\o/\\o/")
|
|
print("[levels#_check_victory_condition] Win !!")
|
|
Global.goto_scene("res://scenes/UI/ending/Ending.tscn")
|
|
|
|
func _node_to_mesh(key):
|
|
return get_node_or_null(meshes[key].mesh())
|
|
|
|
func _node_to_area(key):
|
|
return get_node_or_null(meshes[key].mesh() + "/Area3D")
|
|
|
|
func _node_object_list(key):
|
|
var animation_played = null
|
|
|
|
for child in $ListObjects/ListContainer.get_children():
|
|
if child.has_meta("name"):
|
|
if child.get_meta("name") == meshes[key].label():
|
|
child.set_meta("counted", child.get_meta("counted") + 1)
|
|
|
|
if child.get_meta("counter") == child.get_meta("counted"):
|
|
animation_played = child.get_meta("name")
|
|
else:
|
|
var diff = child.get_meta("counter") - child.get_meta("counted")
|
|
var txt = child.get_meta("name")
|
|
if diff != 1:
|
|
txt = txt + " " + str(diff)
|
|
animation_played = child.get_meta("animation")
|
|
child.get_node("Label").set_text(txt)
|
|
|
|
$ListObjects/AnimationPlayer.queue(animation_played)
|
|
|
|
func _input(event):
|
|
if event is InputEventMouseButton or event is InputEventScreenTouch:
|
|
var camera = $"MainCamera"
|
|
from = camera.project_ray_origin(event.position)
|
|
to = from + camera.project_ray_normal(event.position) * RAY_LENGTH
|
|
|
|
func _physics_process(_delta):
|
|
var space_state = get_world_3d().direct_space_state
|
|
if from != null and to != null:
|
|
_check_collider(space_state)
|
|
|
|
func _check_collider(space_state):
|
|
var query = PhysicsRayQueryParameters3D.create(from, to)
|
|
query.collision_mask = 1
|
|
query.collide_with_bodies = false
|
|
query.collide_with_areas = true
|
|
var result = space_state.intersect_ray(query)
|
|
from = null
|
|
to = null
|
|
if result.has("collider"):
|
|
var node = result["collider"].get_parent()
|
|
if node != null:
|
|
_start_dissolve(node.name)
|