Vaillant Jeremy
238fccef95
- Global.gd: move @onready var animation below the regular vars
(gdlint class-definitions-order expects onready vars after
public/private vars).
- Database.gd::DB: move the three _*_PROPS constants above the vars
(constants come before vars in a class body).
- Levels.gd:_search_button_to_use: drop the elif after a branch
that returns (no-elif-return).
- Levels.gd:_gyroscope_changed_{down,up}: continuation lines of the
multi-line return mixed two tabs + three spaces; normalised to
pure tabs.
No semantic change: @onready is property-level so source ordering
doesn't affect init; elif after a return is equivalent to if; the
continuation indent is cosmetic.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
258 lines
8.9 KiB
GDScript
258 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")
|
|
|
|
var gyroscope_value_old := Vector3(0, 0, 0)
|
|
var meshes: Dictionary[String, SceneEntry] = {}
|
|
var from = null
|
|
var to = null
|
|
var victory_condition: String = "0"
|
|
var victory_progress: String = "0"
|
|
var last_button: Node = null
|
|
|
|
func _ready() -> void:
|
|
_load_meshes()
|
|
_load_back_button()
|
|
_load_prepare_victory_condition()
|
|
_load_hud_menu()
|
|
_load_ambient_sound()
|
|
|
|
func _load_meshes() -> void:
|
|
for scene in Global.database.scenes_for_level(Global.current_scene_int):
|
|
meshes[scene.key] = scene
|
|
create_dissolve_mesh(scene.key)
|
|
|
|
func _load_back_button() -> void:
|
|
$Quit/TextureButton.pressed.connect(Event._on_main_scene_pressed)
|
|
|
|
func _load_prepare_victory_condition() -> void:
|
|
var level: LevelEntry = Global.database.level_by_index(Global.current_scene_int)
|
|
if level == null:
|
|
return
|
|
victory_condition = level.object_to_find()
|
|
victory_progress = level.object_finding()
|
|
|
|
func _load_hud_menu() -> void:
|
|
var counter := 0
|
|
var label_counter: String = ""
|
|
for key in meshes:
|
|
var scene: SceneEntry = meshes[key]
|
|
_create_button_info(scene, counter, label_counter)
|
|
label_counter = scene.label_counter
|
|
counter += 1
|
|
|
|
func _load_ambient_sound() -> void:
|
|
if Setting.get_setting_ambient_sound():
|
|
$AmbientSound.play()
|
|
$AmbientSound.stream_paused = false
|
|
|
|
func _create_button_info(scene: SceneEntry, counter: int, label_counter: String) -> void:
|
|
var button := _search_button_to_use(counter)
|
|
var label_name := scene.label
|
|
|
|
if label_counter != "" 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() -> Node:
|
|
return $ListObjects/ListContainer.get_child($ListObjects/ListContainer.get_child_count() - 1)
|
|
|
|
func _search_button_to_use(counter: int) -> Node:
|
|
if counter == 0:
|
|
return object_first.instantiate()
|
|
if counter == meshes.size() - 1:
|
|
return object_last.instantiate()
|
|
return object_std.instantiate()
|
|
|
|
func _configure_button_object(button: Node, scene: SceneEntry, label: String) -> void:
|
|
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: Node, p_name: String) -> void:
|
|
_add_animation_to_player(p_name, GameAnimation.level_hud_slide(node))
|
|
|
|
func _create_animation_warning(node: Node, p_name: String) -> void:
|
|
_add_animation_to_player(p_name, GameAnimation.level_hud_warning(node))
|
|
|
|
func _add_animation_to_player(p_name: String, anim: Animation) -> void:
|
|
var player: AnimationPlayer = $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: float) -> void:
|
|
_check_dissolve_mesh()
|
|
_check_change_angle_camera()
|
|
_check_victory_condition()
|
|
|
|
func create_dissolve_mesh(key: String) -> void:
|
|
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() -> void:
|
|
# Event dissolve in object searched by gamer
|
|
for key in meshes:
|
|
var scene: SceneEntry = meshes[key]
|
|
if not scene.lock or scene.dissolved:
|
|
continue
|
|
var mesh := _node_to_mesh(key)
|
|
if mesh == null:
|
|
continue
|
|
if scene.dissolve_tick_reference == 0:
|
|
scene.dissolve_tick_reference = Time.get_ticks_msec()
|
|
_node_object_list(key)
|
|
GameAnimation.start_dissolve(mesh, mesh.get_active_material(0))
|
|
if Time.get_ticks_msec() < scene.dissolve_tick_reference + TIME_MAX:
|
|
scene.dissolve_value += 0.01
|
|
else:
|
|
_clean_mesh(key)
|
|
|
|
func _clean_mesh(key: String) -> void:
|
|
var level: LevelEntry = Global.database.level_by_index(Global.current_scene_int)
|
|
if level != null:
|
|
victory_progress = level.object_finding()
|
|
var mesh := _node_to_mesh(key)
|
|
if mesh != null:
|
|
mesh.call_deferred("free")
|
|
meshes[key].dissolved = true
|
|
|
|
func _check_change_angle_camera() -> void:
|
|
var camera: Camera3D = $"MainCamera"
|
|
var gyroscope := Input.get_gyroscope()
|
|
|
|
if camera.h_offset >= -OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_left") or _action_gyroscope("left", gyroscope):
|
|
$"Main Camera3D".h_offset -= OFFSET_STEP_CHANGE
|
|
|
|
if camera.h_offset <= OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_right") or _action_gyroscope("right", gyroscope):
|
|
$"Main Camera3D".h_offset += OFFSET_STEP_CHANGE
|
|
|
|
if camera.v_offset >= -OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_down") or _action_gyroscope("down", gyroscope):
|
|
$"Main Camera3D".v_offset -= OFFSET_STEP_CHANGE
|
|
|
|
if camera.v_offset <= OFFSET_CAMERA_MAX:
|
|
if _action_pressed("ui_up") or _action_gyroscope("up", gyroscope):
|
|
$"Main Camera3D".v_offset += OFFSET_STEP_CHANGE
|
|
|
|
gyroscope_value_old = gyroscope
|
|
|
|
func _action_pressed(action: String) -> bool:
|
|
return Input.is_action_pressed(action)
|
|
|
|
func _action_gyroscope(action: String, gyroscope: Vector3) -> bool:
|
|
if not Setting.get_setting_gyrosocpe():
|
|
return false
|
|
var expression := Expression.new()
|
|
expression.parse("_gyroscope_changed_" + action + "(gyroscope)", ["gyroscope"])
|
|
return bool(expression.execute([gyroscope], self))
|
|
|
|
func _gyroscope_changed_left(gyroscope: Vector3) -> bool:
|
|
return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.y < gyroscope_value_old.y
|
|
|
|
func _gyroscope_changed_right(gyroscope: Vector3) -> bool:
|
|
return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
|
|
gyroscope.y > gyroscope_value_old.y
|
|
|
|
func _gyroscope_changed_down(gyroscope: Vector3) -> bool:
|
|
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: Vector3) -> bool:
|
|
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: String) -> void:
|
|
if not meshes.has(key):
|
|
return
|
|
var scene: SceneEntry = meshes[key]
|
|
if scene.lock:
|
|
return
|
|
scene.lock = true
|
|
Global.database.save()
|
|
$ObjectFind.stream = scene.audio_sound()
|
|
$ObjectFind.play()
|
|
|
|
func _check_victory_condition() -> void:
|
|
if victory_condition == victory_progress:
|
|
Global.goto_scene("res://scenes/UI/ending/Ending.tscn")
|
|
|
|
func _node_to_mesh(key: String) -> MeshInstance3D:
|
|
if not meshes.has(key):
|
|
return null
|
|
return get_node_or_null(meshes[key].mesh_path()) as MeshInstance3D
|
|
|
|
func _node_object_list(key: String) -> void:
|
|
var animation_played: String = ""
|
|
for child in $ListObjects/ListContainer.get_children():
|
|
if not child.has_meta("name"):
|
|
continue
|
|
if child.get_meta("name") != meshes[key].label:
|
|
continue
|
|
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: int = child.get_meta("counter") - child.get_meta("counted")
|
|
var txt: String = 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: InputEvent) -> void:
|
|
if event is InputEventMouseButton or event is InputEventScreenTouch:
|
|
var camera: Camera3D = $"MainCamera"
|
|
from = camera.project_ray_origin(event.position)
|
|
to = from + camera.project_ray_normal(event.position) * RAY_LENGTH
|
|
|
|
func _physics_process(_delta: float) -> void:
|
|
var space_state := get_world_3d().direct_space_state
|
|
if from != null and to != null:
|
|
_check_collider(space_state)
|
|
|
|
func _check_collider(space_state: PhysicsDirectSpaceState3D) -> void:
|
|
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: Node = result["collider"].get_parent()
|
|
if node != null:
|
|
_start_dissolve(node.name)
|