vincent.p.mercier/Kalulu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove useless newlines

Browse Source
This commit is contained in:
Adrien Ufferte
2025-12-16 09:20:14 +01:00
parent 014c5166f9
commit 4764fc21ba
1 changed files with 7 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sources/gardens/gardens.gd
+7 -103
View File
@@ -368,7 +368,6 @@ static func _get_garden_background_image(garden_color_index: int) -> Image:
if error != OK:
Log.warn("Gardens: Unable to load garden texture %s (error %s), skipping transparency validation" % [path, str(error)])
return null
garden_alpha_cache[garden_color_index] = garden_image
return garden_image
@@ -378,7 +377,6 @@ static func _get_garden_dimensions(garden_color_index: int, garden_image: Image
garden_image = _get_garden_background_image(garden_color_index)
if not garden_image:
return Vector2(GARDEN_SIZE, LESSON_VERTICAL_BASE + LESSON_VERTICAL_RANGE)
var width_scale: float = float(GARDEN_SIZE) / float(maxf(1, garden_image.get_width()))
return Vector2(GARDEN_SIZE, float(garden_image.get_height()) * width_scale)
@@ -386,7 +384,6 @@ static func _get_garden_dimensions(garden_color_index: int, garden_image: Image
static func _get_lesson_button_half_size() -> Vector2:
if lesson_button_half_size != Vector2.ZERO:
return lesson_button_half_size
var button: LessonButton = Garden.LESSON_BUTTON_SCENE.instantiate()
var measured_size: Vector2 = button.get_combined_minimum_size()
if measured_size == Vector2.ZERO:
@@ -395,7 +392,6 @@ static func _get_lesson_button_half_size() -> Vector2:
measured_size = button.texture_normal.get_size()
if measured_size == Vector2.ZERO:
measured_size = Vector2(300, 300)
lesson_button_half_size = measured_size * 0.5
return lesson_button_half_size
@@ -411,10 +407,8 @@ static func _clamp_position_to_garden(tested_position: Vector2, garden_dimension
static func _build_probe_offsets(probe_half_size: Vector2) -> Array[Vector2]:
var offsets: Array[Vector2] = []
offsets.append(Vector2.ZERO)
if probe_half_size == Vector2.ZERO:
return offsets
offsets.append_array([
Vector2(probe_half_size.x, 0.0),
Vector2(-probe_half_size.x, 0.0),
@@ -425,7 +419,6 @@ static func _build_probe_offsets(probe_half_size: Vector2) -> Array[Vector2]:
Vector2(-probe_half_size.x, probe_half_size.y),
Vector2(-probe_half_size.x, -probe_half_size.y),
])
var sample_step: float = maxf(1.0, minf(probe_half_size.x, probe_half_size.y) * 0.5)
var x: float = -probe_half_size.x
while x <= probe_half_size.x:
@@ -434,68 +427,44 @@ static func _build_probe_offsets(probe_half_size: Vector2) -> Array[Vector2]:
offsets.append(Vector2(x, y))
y += sample_step
x += sample_step
return offsets
static func _position_to_pixel(sample: Vector2, safe_dim: Vector2, image: Image) -> Vector2i:
var width: float = maxf(1.0, image.get_width())
var height: float = maxf(1.0, image.get_height())
var normalized: Vector2 = Vector2(
clampf(sample.x / safe_dim.x, 0.0, 1.0),
clampf(sample.y / safe_dim.y, 0.0, 1.0)
)
return Vector2i(
int(normalized.x * (width - 1.0)),
int(normalized.y * (height - 1.0))
)
return Vector2i(int(normalized.x * (width - 1.0)), int(normalized.y * (height - 1.0)))
static func _is_position_on_garden_texture(
garden_color_index: int,
tested_position: Vector2,
garden_dimensions: Vector2,
probe_half_size: Vector2 = Vector2.ZERO,
garden_image: Image = null
) -> bool:
static func _is_position_on_garden_texture(garden_color_index: int, tested_position: Vector2, garden_dimensions: Vector2, probe_half_size: Vector2 = Vector2.ZERO, garden_image: Image = null) -> bool:
if not garden_image:
garden_image = _get_garden_background_image(garden_color_index)
if not garden_image:
return true
var safe_dim: Vector2 = _safe_dimensions(garden_dimensions)
var base_position: Vector2 = tested_position if probe_half_size == Vector2.ZERO else tested_position + probe_half_size
var offsets: Array[Vector2] = _build_probe_offsets(probe_half_size)
for offset: Vector2 in offsets:
var sample: Vector2 = base_position + offset
if sample.x < 0.0 or sample.x > safe_dim.x or sample.y < 0.0 or sample.y > safe_dim.y:
return false
var pixel: Vector2i = _position_to_pixel(sample, safe_dim, garden_image)
if garden_image.get_pixelv(pixel).a < TRANSPARENCY_THRESHOLD:
return false
return true
static func _find_valid_position_on_garden(
garden_color_index: int,
tested_position: Vector2,
garden_dimensions: Vector2,
probe_half_size: Vector2 = Vector2.ZERO
) -> Vector2:
static func _find_valid_position_on_garden(garden_color_index: int, tested_position: Vector2, garden_dimensions: Vector2, probe_half_size: Vector2 = Vector2.ZERO) -> Vector2:
var garden_image: Image = _get_garden_background_image(garden_color_index)
if not garden_image:
return _clamp_position_to_garden(tested_position, garden_dimensions, probe_half_size)
var clamped: Vector2 = _clamp_position_to_garden(tested_position, garden_dimensions, probe_half_size)
if _is_position_on_garden_texture(garden_color_index, clamped, garden_dimensions, probe_half_size, garden_image):
return clamped
# Try moving toward the center first (helps for very irregular shapes).
var center: Vector2 = garden_dimensions * 0.5
var toward_center: Vector2 = (center - clamped).normalized()
@@ -505,19 +474,16 @@ static func _find_valid_position_on_garden(
var candidate: Vector2 = _clamp_position_to_garden(clamped + toward_center * float(radius), garden_dimensions, probe_half_size)
if _is_position_on_garden_texture(garden_color_index, candidate, garden_dimensions, probe_half_size, garden_image):
return candidate
# Radial scan around the point.
var angles: Array[float] = []
for angle_deg: int in range(0, 360, 30):
angles.append(deg_to_rad(angle_deg))
for radius: int in range(POSITION_SEARCH_STEP, MAX_POSITION_SEARCH_RADIUS + POSITION_SEARCH_STEP, POSITION_SEARCH_STEP):
for angle: float in angles:
var offset: Vector2 = Vector2.RIGHT.rotated(angle) * float(radius)
var candidate2: Vector2 = _clamp_position_to_garden(clamped + offset, garden_dimensions, probe_half_size)
if _is_position_on_garden_texture(garden_color_index, candidate2, garden_dimensions, probe_half_size, garden_image):
return candidate2
return clamped
@@ -530,71 +496,51 @@ static func _find_overlapping_position_index(tested_position: Vector2, placed_po
return -1
static func _separate_lesson_position(
tested_position: Vector2,
garden_color_index: int,
garden_dimensions: Vector2,
placed_positions: Array[Vector2],
half_size: Vector2
) -> Vector2:
static func _separate_lesson_position(tested_position: Vector2, garden_color_index: int, garden_dimensions: Vector2, placed_positions: Array[Vector2], half_size: Vector2) -> Vector2:
var adjusted: Vector2 = tested_position
var minimum_spacing: float = maxf(half_size.x, half_size.y) * 2.0 + 8.0
for _attempt: int in range(8):
var overlap_index: int = _find_overlapping_position_index(adjusted, placed_positions, minimum_spacing)
if overlap_index == -1:
return adjusted
var overlap_gap: float = minimum_spacing - adjusted.distance_to(placed_positions[overlap_index])
var vertical_offset: float = overlap_gap + half_size.y
var lifted: Vector2 = _find_valid_position_on_garden(garden_color_index, adjusted + Vector2(0.0, -vertical_offset), garden_dimensions, half_size)
if _find_overlapping_position_index(lifted, placed_positions, minimum_spacing) == -1:
adjusted = lifted
continue
var shifted_previous: Vector2 = _find_valid_position_on_garden(garden_color_index, placed_positions[overlap_index] + Vector2(-minimum_spacing, 0.0), garden_dimensions, half_size)
if _find_overlapping_position_index(shifted_previous, placed_positions, minimum_spacing, overlap_index) == -1:
placed_positions[overlap_index] = shifted_previous
continue
var shifted_right: Vector2 = _find_valid_position_on_garden(garden_color_index, adjusted + Vector2(minimum_spacing, 0.0), garden_dimensions, half_size)
if _find_overlapping_position_index(shifted_right, placed_positions, minimum_spacing) == -1:
adjusted = shifted_right
continue
break
return adjusted
static func compute_lessons_distribution(total_lessons: int, garden_layouts: Array[GardenLayout]) -> Array[int]:
Log.info("Gardens: Computing lessons distribution")
Log.trace("Gardens: ComputeLessonsDistribution: Parameters total_lessons = %s, garden_layouts count = %s" % [str(total_lessons), str(garden_layouts.size())])
var distribution: Array[int] = []
var lessons_left: int = total_lessons
var gardens_left: int = garden_layouts.size()
for layout_index: int in range(garden_layouts.size()):
var max_lessons: int = garden_layouts[layout_index].lesson_buttons.size()
Log.trace("Gardens: Garden index %s can host up to %s lessons" % [str(layout_index), str(max_lessons)])
var lessons_for_garden: int = 0
if gardens_left > 0:
lessons_for_garden = int(ceili(float(lessons_left) / float(gardens_left)))
lessons_for_garden = min(lessons_for_garden, max_lessons)
if lessons_for_garden > lessons_left:
lessons_for_garden = lessons_left
distribution.append(lessons_for_garden)
Log.trace("Gardens: Assigning %s lessons to garden index %s (lessons left before assignment: %s)" % [str(lessons_for_garden), str(layout_index), str(lessons_left)])
lessons_left -= lessons_for_garden
gardens_left -= 1
Log.trace("Gardens: Lessons left after assignment: %s, gardens left: %s" % [str(lessons_left), str(gardens_left)])
return distribution
@@ -602,28 +548,21 @@ static func generate_gardens_layout(total_lessons: int) -> GardensLayout:
var layout: GardensLayout = GardensLayout.new()
if total_lessons <= 0:
return layout
Log.info("Gardens: Generating dynamic gardens layout")
Log.trace("Gardens: Total lessons to layout: %s" % str(total_lessons))
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.seed = 13985
Log.trace("Gardens: RNG seeded with %s" % str(rng.seed))
var lessons_left: int = total_lessons
var garden_index: int = 0
while lessons_left > 0 and garden_index < GARDEN_TEXTURES_NB:
var gardens_left: int = GARDEN_TEXTURES_NB - garden_index
var lessons_for_garden: int = int(ceili(float(lessons_left) / float(gardens_left)))
Log.trace("Gardens: Generating layout for garden %s with %s lessons left" % [str(garden_index), str(lessons_left)])
layout.gardens.append(_generate_single_garden_layout(garden_index, lessons_for_garden, rng))
lessons_left -= lessons_for_garden
Log.trace("Gardens: Lessons left after garden %s generation: %s" % [str(garden_index), str(lessons_left)])
garden_index += 1
Log.info("Gardens: Completed layout generation with %s gardens" % str(layout.gardens.size()))
return layout
@@ -631,43 +570,36 @@ static func generate_gardens_layout(total_lessons: int) -> GardensLayout:
static func _generate_single_garden_layout(garden_index: int, lessons_for_garden: int, rng: RandomNumberGenerator) -> GardenLayout:
Log.info("Gardens: Generating single garden layout for garden %s" % str(garden_index))
Log.trace("Gardens: Garden %s will include %s lessons" % [str(garden_index), str(lessons_for_garden)])
var garden_layout: GardenLayout = GardenLayout.new()
garden_layout.color = garden_index % GARDEN_TEXTURES_NB
Log.trace("Gardens: Garden %s color index set to %s" % [str(garden_index), str(garden_layout.color)])
var garden_image: Image = _get_garden_background_image(garden_layout.color)
var garden_dimensions: Vector2 = _get_garden_dimensions(garden_layout.color, garden_image)
var half_size: Vector2 = _get_lesson_button_half_size()
# Step 1: initial path positions
var raw_positions: Array[Vector2i] = _generate_lesson_positions(lessons_for_garden, garden_index)
# Step 2: clamp to texture + avoid overlaps
var resolved_positions: Array[Vector2] = []
for lesson_index: int in range(lessons_for_garden):
var pos: Vector2 = Vector2(raw_positions[lesson_index])
var valid: Vector2 = _find_valid_position_on_garden(garden_layout.color, pos, garden_dimensions, half_size)
var separated: Vector2 = _separate_lesson_position(valid, garden_layout.color, garden_dimensions, resolved_positions, half_size)
if not separated.is_equal_approx(valid):
Log.trace("Gardens: Separated lesson %s position from %s to %s to avoid overlap" % [str(lesson_index), str(valid), str(separated)])
resolved_positions.append(separated)
var rounded: Vector2i = _round_vec2(separated)
if not (rounded as Vector2).is_equal_approx(raw_positions[lesson_index]):
Log.trace("Gardens: Adjusted lesson %s position from %s to %s to stay on background" % [str(lesson_index), str(raw_positions[lesson_index]), str(rounded)])
raw_positions[lesson_index] = rounded
Log.trace("Gardens: Garden %s lesson %s position calculated at %s" % [str(garden_index), str(lesson_index), str(rounded)])
# Step 3: build lesson buttons with tangents
var lesson_buttons: Array[GardenLayout.GardenLayoutLessonButton] = []
for lesson_index: int in range(resolved_positions.size()):
var lesson_position: Vector2i = _round_vec2(resolved_positions[lesson_index])
var path_out: Vector2i = Vector2i.ZERO
if lesson_index + 1 < resolved_positions.size():
var next_position: Vector2 = resolved_positions[lesson_index + 1]
var tangent: Vector2 = (next_position - resolved_positions[lesson_index]) * 0.5
@@ -676,9 +608,7 @@ static func _generate_single_garden_layout(garden_index: int, lessons_for_garden
else:
path_out = Vector2i(int(GARDEN_SIZE * 0.15), int((-1.0 if (garden_index % 2) == 0 else 1.0) * 60))
Log.trace("Gardens: Garden %s last lesson %s path out set to %s" % [str(garden_index), str(lesson_index), str(path_out)])
lesson_buttons.append(GardenLayout.GardenLayoutLessonButton.new(lesson_position, path_out))
garden_layout.lesson_buttons = lesson_buttons
# Step 4: build flowers (keep RNG call order identical)
@@ -686,20 +616,15 @@ static func _generate_single_garden_layout(garden_index: int, lessons_for_garden
for lesson_index: int in range(resolved_positions.size()):
var flower_position: Vector2i = _round_vec2(resolved_positions[lesson_index])
flower_position.y = max(0, flower_position.y - int(FLOWER_OFFSET_FROM_LESSON))
var flower_color: int = garden_layout.color
var flower_type: int = (lesson_index + garden_index + rng.randi_range(0, FLOWER_TYPES_NB - 1)) % FLOWER_TYPES_NB
var adjusted: Vector2 = _find_valid_position_on_garden(garden_layout.color, Vector2(flower_position), garden_dimensions)
if not adjusted.is_equal_approx(Vector2(flower_position)):
Log.trace("Gardens: Adjusted flower %s position from %s to %s to stay on background" % [str(lesson_index), str(flower_position), str(adjusted)])
flower_position = _round_vec2(adjusted)
Log.trace("Gardens: Garden %s flower %s position (%s,%s), color %s, type %s" % [str(garden_index), str(lesson_index), str(flower_position.x), str(flower_position.y), str(flower_color), str(flower_type)])
flowers.append(GardenLayout.Flower.new(flower_color, flower_type, flower_position))
garden_layout.flowers = flowers
Log.info("Gardens: Finished generating garden layout for garden %s" % str(garden_index))
return garden_layout
@@ -737,17 +662,13 @@ func _get_minigame_layouts() -> Array[MinigameLayout]:
func _open_minigames_layout(button: LessonButton, lesson_ind: int) -> void:
if in_minigame_selection or not UserDataManager.student_progression:
return
feedback_audio_stream_player2.pitch_scale = 1.1
feedback_audio_stream_player2.play()
in_minigame_selection = true
# Gets the correct exercises for the lesson
var exercises: Array[int] = Database.get_exercise_for_lesson(lesson_ind)
if not exercises or exercises.size() < 3:
return
# Sets the variables for the current garden and lesson
current_lesson_number = lesson_ind
if button:
@@ -755,44 +676,34 @@ func _open_minigames_layout(button: LessonButton, lesson_ind: int) -> void:
current_button = button
current_button.show_placeholder(true)
current_button_global_position = button.global_position
# Gets the current lesson unlocks
var lesson_unlocks: Dictionary = UserDataManager.student_progression.unlocks[current_lesson_number]
var are_minigames_locked: bool = lesson_unlocks["games"][0] == StudentProgression.Status.Locked and lesson_unlocks["games"][1] == StudentProgression.Status.Locked and lesson_unlocks["games"][2] == StudentProgression.Status.Locked
# Deactivate the mouse filters on the buttons behind the layout
for l_button: LessonButton in current_garden.get_lesson_buttons():
l_button.mouse_filter = Control.MOUSE_FILTER_IGNORE
# Background
if are_minigames_locked:
minigame_background_center.modulate = locked_color
else:
minigame_background_center.modulate = current_garden.color
# Lesson button
_handle_lesson_button(current_lesson_number, lesson_unlocks["look_and_learn"] as StudentProgression.Status, current_garden.color)
# Minigames
var minigame_layouts: Array[MinigameLayout] = _get_minigame_layouts()
for layout_index: int in minigame_layouts.size():
_fill_minigame_choice(minigame_layouts[layout_index], exercises[layout_index], lesson_unlocks["games"][layout_index] as StudentProgression.Status, layout_index)
# Animations
minigame_selection.show()
back_button.hide()
kalulu_button.hide()
line_particles.hide()
minigame_background.size = 300.0 * Vector2.ONE
minigame_background.global_position = current_button_global_position
minigame_background.show()
minigame_background_center.size = 300.0 * Vector2.ONE
minigame_background_center.global_position = current_button_global_position
minigame_background_center.show()
var tween: Tween = create_tween().set_parallel(true).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_BACK)
tween.tween_property(minigame_background_center, "scale", (1800.0 / 300.0) * Vector2.ONE, 0.25)
tween.tween_property(minigame_background_center, "global_position", Vector2(380.0, 0), 0.25)
@@ -800,18 +711,15 @@ func _open_minigames_layout(button: LessonButton, lesson_ind: int) -> void:
tween.tween_property(minigame_background, "global_position", Vector2(380.0, 0), 0.25)
tween.chain().tween_property(minigame_selection, "modulate:a", 1.0, 0.25)
await tween.finished
minigame_layout_opened.emit()
func _handle_lesson_button(lesson: int, status: StudentProgression.Status, color: Color) -> void:
lesson_button.text = lessons[lesson][0].grapheme
lesson_button.completed_color = color
lesson_button.set_disabled(status == StudentProgression.Status.Locked)
lesson_button.completed = status == StudentProgression.Status.Completed
lesson_button_particles.emitting = status == StudentProgression.Status.Unlocked
if status == StudentProgression.Status.Completed:
if transition_data and transition_data.has("look_and_learn_completed") and transition_data.look_and_learn_completed:
await minigame_layout_opened
@@ -829,7 +737,6 @@ func _fill_minigame_choice(layout: MinigameLayout, exercise_type: int, status: S
layout.right()
else:
layout.self_modulate.a = 0
elif status == StudentProgression.Status.Locked:
layout.self_modulate = locked_color
else:
@@ -915,7 +822,6 @@ func set_gardens_layout(p_gardens_layout: GardensLayout) -> void:
func add_gardens() -> void:
if not garden_parent:
return
# Removes old gardens
Log.info("Gardens: Clearing existing gardens before generation")
for child: Node in garden_parent.get_children():
child.free()
@@ -1054,10 +960,8 @@ func _on_scroll_container_gui_input(event: InputEvent) -> void:
if is_garden_changed:
current_garden = garden_parent.get_child(int(float(target_scroll) / GARDEN_SIZE))
current_garden.pop_animation()
await scroll_tween.finished
scroll_beginning_garden = int(float(scroll_container.scroll_horizontal) / GARDEN_SIZE)
if is_scrolling and event is InputEventMouseMotion:
var motion_event: InputEventMouseMotion = event
scroll_container.scroll_horizontal -= int(motion_event.relative.x)