211 lines
6.6 KiB
GDScript
211 lines
6.6 KiB
GDScript
extends Node3D
|
|
|
|
# Die richtige Lösung als String (z.B. "12345678")
|
|
@export var correct_solution: String = "63852471"
|
|
|
|
# Referenzen zu den 8 SnapZones
|
|
var snap_zones: Array[Node] = []
|
|
|
|
# Dictionary: Key = SnapZone Position (1-8), Value = Cube Nummer (String)
|
|
var cube_positions: Dictionary = {}
|
|
|
|
# Signal wenn alle Cubes platziert sind
|
|
signal all_cubes_placed
|
|
signal solution_correct
|
|
signal solution_incorrect
|
|
|
|
func _ready():
|
|
# Sammle alle SnapZones (cubePos_1 bis cubePos_8)
|
|
for i in range(1, 9):
|
|
var snap_zone = get_node_or_null("cubePos_" + str(i))
|
|
if snap_zone:
|
|
snap_zones.append(snap_zone)
|
|
|
|
# Verbinde nur das has_picked_up Signal (wird für beides verwendet)
|
|
if snap_zone.has_signal("has_picked_up"):
|
|
snap_zone.has_picked_up.connect(_on_cube_picked_up)
|
|
else:
|
|
push_error("SnapZone cubePos_" + str(i) + " nicht gefunden!")
|
|
|
|
print("RiddelCubeBoard bereit mit ", snap_zones.size(), " SnapZones")
|
|
print("Warte auf Cubes...")
|
|
|
|
func _on_cube_dropped(what = null):
|
|
"""Wird aufgerufen wenn ein Cube in eine SnapZone gelegt wird"""
|
|
print("_on_cube_dropped aufgerufen - Parameter: ", what, " (Typ: ", typeof(what), ")")
|
|
# Kurze Verzögerung, damit der Cube richtig platziert ist
|
|
await get_tree().create_timer(0.1).timeout
|
|
update_cube_positions()
|
|
check_if_complete()
|
|
|
|
func _on_cube_picked_up(what = null):
|
|
"""Wird aufgerufen wenn ein Cube aufgenommen oder abgelegt wird"""
|
|
print("_on_cube_picked_up aufgerufen - Parameter: ", what, " (Typ: ", typeof(what), ")")
|
|
|
|
if what is Node:
|
|
print(" -> Objekt-Interaktion: ", what.name)
|
|
|
|
# Kurze Verzögerung, damit der Status aktualisiert ist
|
|
await get_tree().create_timer(0.1).timeout
|
|
update_cube_positions()
|
|
check_if_complete()
|
|
|
|
func check_if_complete():
|
|
"""Prüft ob alle 8 Positionen belegt sind"""
|
|
if is_complete():
|
|
print("Alle Cubes sind platziert!")
|
|
print("Aktuelle Positionen: ", cube_positions)
|
|
all_cubes_placed.emit()
|
|
check_solution()
|
|
|
|
func update_cube_positions():
|
|
"""Aktualisiert das Dictionary mit den aktuellen Cube-Positionen"""
|
|
cube_positions.clear()
|
|
|
|
for i in range(1, 9):
|
|
var cube = get_cube_at_position(i)
|
|
if cube != null:
|
|
print("DEBUG: Cube an Position ", i, " gefunden: ", cube.name)
|
|
|
|
var cube_number = ""
|
|
|
|
# Versuche direkt auf cubeNumber zuzugreifen
|
|
if "cubeNumber" in cube:
|
|
cube_number = str(cube.cubeNumber)
|
|
print(" -> cubeNumber direkt gefunden: '", cube_number, "'")
|
|
else:
|
|
# Suche in den Kindern (MeshInstance3D)
|
|
print(" -> Suche cubeNumber in Kindern...")
|
|
for child in cube.get_children():
|
|
if "cubeNumber" in child:
|
|
cube_number = str(child.cubeNumber)
|
|
print(" -> cubeNumber in Kind gefunden: '", cube_number, "' (", child.name, ")")
|
|
break
|
|
|
|
if cube_number != "" and cube_number != "0":
|
|
cube_positions[i] = cube_number
|
|
print(" ✓ Position ", i, ": Cube mit Nummer ", cube_number)
|
|
else:
|
|
print(" ✗ Cube hat keine gültige Nummer (leer oder 0)")
|
|
|
|
print("Cube Positionen aktualisiert: ", cube_positions)
|
|
|
|
func is_complete() -> bool:
|
|
"""Prüft ob alle 8 SnapZones einen Cube haben"""
|
|
for snap_zone in snap_zones:
|
|
if snap_zone.has_method("has_snapped_object"):
|
|
if not snap_zone.has_snapped_object():
|
|
return false
|
|
else:
|
|
return false
|
|
return true
|
|
|
|
func get_cube_at_position(position_index: int) -> Node3D:
|
|
"""
|
|
Gibt den Cube an einer bestimmten Position zurück (1-8)
|
|
"""
|
|
if position_index < 1 or position_index > 8:
|
|
push_error("Position muss zwischen 1 und 8 sein!")
|
|
return null
|
|
|
|
var snap_zone = snap_zones[position_index - 1]
|
|
if snap_zone == null:
|
|
print("SnapZone an Position ", position_index, " ist null!")
|
|
return null
|
|
|
|
# Debug: Prüfe den Status der SnapZone
|
|
var has_object = snap_zone.has_snapped_object() if snap_zone.has_method("has_snapped_object") else false
|
|
print("Position ", position_index, ": has_snapped_object = ", has_object)
|
|
|
|
# XRToolsSnapZone spezifische Methode
|
|
if snap_zone.has_method("has_snapped_object") and snap_zone.has_snapped_object():
|
|
# Versuche verschiedene Properties
|
|
if "picked_up_object" in snap_zone:
|
|
print(" -> Gefunden über picked_up_object: ", snap_zone.picked_up_object)
|
|
return snap_zone.picked_up_object
|
|
elif "snapped_object" in snap_zone:
|
|
print(" -> Gefunden über snapped_object: ", snap_zone.snapped_object)
|
|
return snap_zone.snapped_object
|
|
|
|
# Durchsuche die Kinder der SnapZone
|
|
print(" -> Durchsuche Kinder...")
|
|
for child in snap_zone.get_children():
|
|
print(" Child: ", child.name, " Gruppen: ", child.get_groups())
|
|
if child.is_in_group("RiddelCube"):
|
|
print(" -> Gefunden über Kinder: ", child.name)
|
|
return child
|
|
|
|
return null
|
|
|
|
func get_number_at_position(position_index: int) -> String:
|
|
"""Gibt die Zahl (als String) vom Cube an einer Position zurück"""
|
|
var cube = get_cube_at_position(position_index)
|
|
if cube != null and "cubeNumber" in cube:
|
|
return str(cube.cubeNumber)
|
|
return ""
|
|
|
|
func get_number_sequence() -> String:
|
|
"""
|
|
Liest alle 8 Zahlen in der richtigen Reihenfolge aus
|
|
und gibt sie als String zurück (z.B. "12345678")
|
|
"""
|
|
var sequence = ""
|
|
for i in range(1, 9):
|
|
var number = get_number_at_position(i)
|
|
if number == "":
|
|
# Falls eine Position leer ist, gib leeren String zurück
|
|
return ""
|
|
sequence += number
|
|
return sequence
|
|
|
|
func check_solution() -> bool:
|
|
"""
|
|
Vergleicht die aktuelle Zahlenreihe mit der Lösung.
|
|
Gibt true zurück wenn korrekt, sonst false.
|
|
"""
|
|
var current_sequence = ""
|
|
# Prüfe ob alle Positionen belegt sind
|
|
for value in cube_positions.values():
|
|
current_sequence += value
|
|
|
|
print("Aktuelle Sequenz: ", current_sequence)
|
|
print("Richtige Lösung: ", correct_solution)
|
|
|
|
if current_sequence == correct_solution:
|
|
print("✓ RICHTIG! Lösung ist korrekt!")
|
|
solution_correct.emit()
|
|
on_correct_solution()
|
|
return true
|
|
else:
|
|
print("✗ FALSCH! Versuche es nochmal.")
|
|
solution_incorrect.emit()
|
|
on_incorrect_solution()
|
|
return false
|
|
|
|
func on_correct_solution():
|
|
var box = get_node_or_null("Box")
|
|
if box and box is CSGBox3D:
|
|
var material = StandardMaterial3D.new()
|
|
material.albedo_color = Color.WEB_GREEN
|
|
box.material = material
|
|
|
|
await get_tree().create_timer(2).timeout
|
|
if has_node("AnimationGeheimgang"):
|
|
$AnimationGeheimgang.play("hide_box")
|
|
|
|
# Mache alle platzierten Cubes unsichtbar
|
|
await get_tree().create_timer(1).timeout
|
|
for i in range(1, 9):
|
|
var cube = get_cube_at_position(i)
|
|
if cube != null:
|
|
cube.visible = false
|
|
print("Cube an Position ", i, " unsichtbar gemacht: ", cube.name)
|
|
|
|
func on_incorrect_solution():
|
|
var box = get_node_or_null("Box")
|
|
if box and box is CSGBox3D:
|
|
var material = StandardMaterial3D.new()
|
|
material.albedo_color = Color.DARK_RED
|
|
box.material = material
|
|
|