extends Node3D ## Cena 3D do documentário: os náufragos da Ilha das Cobras (reconstituição do caso de 2019). ## Elenilson (regata cinza, bermuda escura) e três companheiros, do naufrágio do pesqueiro ao ## resgate pela lancha de mergulho, no costão da ilha da biblioteca (res://library/island). ## Tudo depende só de (params, t): poses e barcos animados por tempo, sem física nem relógio. ## ## Modelo "castaways": params ## moment: "arrival" | "sinking" | "swimming" | "waiting" | "rescue" | "boarding" | "departure" ## camera: "medium" (padrão) | "close" (mais perto do Elenilson) | "wide" (mais aberto) ## variant: inteiro; muda o ângulo da câmera (lado, altura e ponto de vista) ## ## Tom sóbrio: sem cobra, sem helicóptero, sem navio militar; a lancha do resgate é civil. const Island := preload("res://library/castaways/shore.gd") const Person := preload("res://library/castaways/actor.gd") const Boat := preload("res://kits/boat.gd") const Cast := preload("res://library/castaways/cast.gd") const SkyRig := preload("res://library/castaways/sky.gd") const MOMENTS := ["arrival", "sinking", "swimming", "waiting", "rescue", "boarding", "departure"] const ZOOM := {"medium": 1.12, "close": 1.0, "wide": 1.3} var _p: Dictionary var _dur = 1.0 var _moment = "arrival" var _variant = 0 var _zoom = 1.0 var _island: Node3D var _sky: Node var _camera: Camera3D var _people = {} # id → Person (Elenilson = "elenilson") var _boat: Node3D # pesqueiro (sinking) ou lancha de mergulho (rescue, boarding, departure) var _seats: Array = [] # pedras de apoio sob quem está sentado no costão var _rock_mat: StandardMaterial3D # Costão escolhido: c = onde o grupo fica; sea = direção do mar; tan = ao longo da costa. var _c = Vector3.ZERO var _sea = Vector3.FORWARD var _tan = Vector3.RIGHT var _spots = {} # id → Vector3 (posição no costão, y = chão) var _last_cam = Vector3.ZERO var _support_points: Dictionary = {} func setup(cfg: Dictionary, viewport_size: Vector2) -> void: _p = cfg.params _dur = maxf(float(cfg.video.duration), 0.1) _moment = str(_p.get("moment", "arrival")) if not (_moment in MOMENTS): _moment = "arrival" _variant = posmod(int(_p.get("variant", 0)), 6) _zoom = float(ZOOM.get(str(_p.get("camera", "medium")), 1.0)) _island = Island.new() _island.name = "Island" add_child(_island) _island.setup({"params": {"embedded": true, "environment": false, "lighthouse": false, "sea_detail": true, "time": "day"}, "video": cfg.video}, viewport_size) _island.set_sea_state(1.7 if _moment == "sinking" else (1.0 if _moment == "swimming" else 0.7)) _rock_mat = StandardMaterial3D.new() _rock_mat.albedo_color = Color("#57534d") _rock_mat.roughness = 1.0 _find_coast() _island.prepare_coast(_c, _sea) for id in _spots: _spots[id] = _ground(_spots[id]) _clear_stage() _sky = SkyRig.new() add_child(_sky) _sky.build(_island.ocean_material(), _sun_dir()) match _moment: "sinking": _sky.set_preset("dusk") "swimming": _sky.set_preset("night") "arrival": _sky.set_preset("dawn") "waiting": _sky.set_preset("night") _: _sky.set_preset("day") _build_cast() _camera = Camera3D.new() _camera.fov = 52.0 _camera.near = 0.08 _camera.far = 9000.0 _camera.keep_aspect = Camera3D.KEEP_HEIGHT add_child(_camera) _camera.current = true func apply(t: float) -> void: _island.apply(t) var p = clampf(t / _dur, 0.0, 1.0) match _moment: "sinking": _do_sinking(t, p) "swimming": _do_swimming(t, p) "waiting": _do_waiting(t, p) "rescue": _do_rescue(t, p) "boarding": _do_boarding(t, p) "departure": _do_departure(t, p) _: _do_arrival(t, p) if _moment in ["arrival", "waiting", "rescue"]: for id in ["elenilson", "ivan", "manoel", "iranildo"]: _fit_ground(_people[id], _moment == "arrival" and id == "elenilson") var shot: Array = _compose_shot(t, p) _place_camera(shot[0], shot[1], shot[2], t) func state_signature() -> String: var e: Node3D = _people.elenilson var ep = e.global_position if e.is_inside_tree() else e.position return "%.3f,%.3f,%.3f|%.3f,%.3f,%.3f" % [_last_cam.x, _last_cam.y, _last_cam.z, ep.x, ep.y, ep.z] # ------------------------------------------------------------------ costão e elenco ## Procura, na costa da ilha, um trecho de pedra baixo, pouco inclinado, perto da água e ## longe das pedras grandes (determinístico: o terreno vem de sementes fixas). func _find_coast() -> void: var best = INF for side in [1.0, -1.0]: for xi in range(-54, 55, 2): var x = float(xi) var z = 0.0 while z < 70.0 and _island.ground_at(x, z * side) > 1.1: z += 0.25 if z >= 70.0: continue var n: Vector3 = _island.ground_normal(x, z * side) var sea = Vector2(n.x, n.z) if sea.length() < 0.05: continue sea = sea.normalized() var c = Vector2(x, z * side) - sea * 1.4 var hmin = INF var hmax = -INF for k in 16: var a = TAU * k / 16.0 for r in [1.0, 2.0, 2.8]: var h: float = _island.ground_at(c.x + cos(a) * r, c.y + sin(a) * r) hmin = minf(hmin, h) hmax = maxf(hmax, h) var water = 0.0 while water < 10.0 and _island.ground_at(c.x + sea.x * water, c.y + sea.y * water) > -0.5: water += 0.25 var clear = INF for rk in _island.rock_list(): clear = minf(clear, Vector2(rk[0].x, rk[0].z).distance_to(c) - float(rk[1])) var score: float = (hmax - hmin) + water * 0.12 + maxf(0.0, 3.0 - clear) * 0.6 if score < best: best = score _c = Vector3(c.x, _island.ground_at(c.x, c.y), c.y) _sea = Vector3(sea.x, 0, sea.y) _tan = Vector3(-_sea.z, 0, _sea.x) print("CASTAWAYS costao c=(%.2f, %.2f, %.2f) mar=(%.2f, %.2f) nota=%.2f" % [_c.x, _c.y, _c.z, _sea.x, _sea.z, best]) # Lugares do grupo no costão (Elenilson mais perto do mar). _spots = { "elenilson": _ground(_c + _sea * 0.2), "ivan": _ground(_c + _tan * 1.7 - _sea * 0.5), "manoel": _ground(_c - _tan * 1.8 - _sea * 0.4), "iranildo": _ground(_c + _tan * 0.5 - _sea * 1.7), } ## Abre somente a área de atuação nesta instância da ilha; a biblioteca original fica intacta. func _clear_stage() -> void: for node_name in ["Forest", "Rocks"]: var node: MultiMeshInstance3D = _island.get_node(node_name) var mm: MultiMesh = node.multimesh for i in mm.instance_count: var tr: Transform3D = mm.get_instance_transform(i) var delta_pos: Vector3 = (tr.origin - _c) * Vector3(1, 0, 1) var corridor: bool = node_name == "Rocks" and delta_pos.dot(_sea) > -4.0 and absf(delta_pos.dot(_tan)) < 12.0 var camera_clear: bool = node_name == "Forest" and _moment == "rescue" and delta_pos.dot(_sea) > -40.0 and absf(delta_pos.dot(_tan)) < 8.0 if delta_pos.length() < 10.0 or corridor or camera_clear: tr.origin.y -= 80.0 mm.set_instance_transform(i, tr) func _ground(v: Vector3) -> Vector3: return Vector3(v.x, _island.ground_at(v.x, v.z), v.z) ## Vértices reais das peças: apoio sobre o terreno depois de aplicar a pose articulada. func _cache_support(person: Node3D) -> void: var parts: Array = [] for mesh in person.find_children("*", "MeshInstance3D", true, false): var vertices: PackedVector3Array = mesh.mesh.surface_get_arrays(0)[Mesh.ARRAY_VERTEX] parts.append([mesh, vertices]) _support_points[person.name] = parts func _fit_ground(person: Node3D, only_raise: bool = false) -> void: var lift: float = -INF for part in _support_points[person.name]: var tr: Transform3D = part[0].global_transform for v in part[1]: var point: Vector3 = tr * v lift = maxf(lift, _island.ground_at(point.x, point.z) - point.y) person.position.y += (maxf(lift, 0.0) if only_raise else lift) + 0.012 func _sun_dir() -> Vector3: match _moment: "sinking": return (_sea * 0.75 - _tan * 0.65).normalized() "swimming": return (-_sea * 0.6 + _tan * 0.8).normalized() "arrival", "waiting": return (_sea * 0.8 + _tan * 0.6).normalized() _: return (_sea * 0.45 + _tan * 0.9).normalized() func _build_cast() -> void: var ids = ["elenilson", "ivan", "manoel", "iranildo"] if _moment == "sinking": ids += ["crew_a", "crew_b"] # o pesqueiro saiu com seis homens for id in ids: var person = Person.new() person.name = id person.build(Cast.LOOKS[id]) _people[id] = person _cache_support(person) match _moment: "sinking": _boat = _make_boat(Cast.FISHING_BOAT) for id in ids: _boat.deck().add_child(_people[id]) "swimming", "arrival", "waiting": for id in ids: add_child(_people[id]) _: _boat = _make_boat(Cast.DIVE_BOAT) _add_benches() for id in ["diver_a", "diver_b"]: var diver = Person.new() diver.name = id diver.build(Cast.LOOKS[id]) _people[id] = diver _boat.deck().add_child(diver) for id in ids: add_child(_people[id]) if _moment in ["arrival", "waiting", "rescue"]: for id in ["elenilson", "iranildo"]: _seats.append(_seat_rock()) func _make_boat(look: Dictionary) -> Node3D: var boat = Boat.new() boat.name = "Boat" boat.build(look) add_child(boat) return boat ## Bancos na popa da lancha (os quatro vão sentados). func _add_benches() -> void: var wood = StandardMaterial3D.new() wood.albedo_color = Color("#e4e1da") for sx in [-1.0, 1.0]: var mesh = BoxMesh.new() mesh.size = Vector3(0.42, 0.3, 2.3) var mi = MeshInstance3D.new() mi.mesh = mesh mi.material_override = wood mi.position = Vector3(sx * 0.84, Boat.DECK_Y + 0.15, 2.15) _boat.deck().add_child(mi) func _seat_rock() -> MeshInstance3D: var mesh = SphereMesh.new() mesh.radius = 0.34 mesh.height = 0.46 mesh.radial_segments = 8 mesh.rings = 4 var mi = MeshInstance3D.new() mi.mesh = mesh mi.material_override = _rock_mat mi.visible = false add_child(mi) return mi # ------------------------------------------------------------------ apoio das poses ## Põe a pessoa no chão do costão: pés em pos (y = chão desenhado), olhando para facing; ## align (0–1) inclina o corpo junto com a pedra (deitado = 1). func _on_ground(person: Node3D, pos: Vector3, facing: Vector3, align := 0.0, lift := 0.0) -> void: var yaw = atan2(-facing.x, -facing.z) var n: Vector3 = _island.ground_normal(pos.x, pos.z) var up = Vector3.UP.lerp(n, align).normalized() var tilt = Quaternion(Vector3.UP, up) if up.distance_to(Vector3.UP) > 0.0001 else Quaternion.IDENTITY person.basis = Basis(tilt) * Basis(Vector3.UP, yaw) person.position = Vector3(pos.x, _island.ground_at(pos.x, pos.z) + lift, pos.z) ## Sentado numa pedra do costão, olhando para facing (pés à frente, quadril sobre a pedra). func _sit_on_rock(person: Node3D, seat: MeshInstance3D, pos: Vector3, facing: Vector3) -> void: var f = facing.normalized() var feet = _island.ground_at(pos.x + f.x * 0.42, pos.z + f.z * 0.42) var under = _island.ground_at(pos.x, pos.z) var y = maxf(feet, under - 0.3) person.basis = Basis(Vector3.UP, atan2(-f.x, -f.z)) person.position = Vector3(pos.x, y, pos.z) seat.visible = true seat.position = Vector3(pos.x, y + 0.3 - 0.21, pos.z) - f * 0.04 ## Deitado de costas ao longo da costa; a altura acompanha o ponto mais alto sob o corpo. func _lie_on_ground(person: Node3D, pos: Vector3, along: Vector3) -> void: var a = along.normalized() var top = -INF for k in [-0.2, 0.3, 0.8, 1.3]: top = maxf(top, _island.ground_at(pos.x + a.x * k, pos.z + a.z * k)) var n: Vector3 = _island.ground_normal(pos.x + a.x * 0.5, pos.z + a.z * 0.5) var tilt = Quaternion(Vector3.UP, n.lerp(Vector3.UP, 0.4).normalized()) # A cabeça fica em +Z da pessoa: olhar para -along põe a cabeça em +along. person.basis = Basis(tilt) * Basis(Vector3.UP, atan2(a.x, a.z)) person.position = Vector3(pos.x, top + 0.04, pos.z) ## Respiração visível (peito e costas), somada à pose. func _breathe(person: Node3D, t: float, amount: float) -> void: person.joints.chest.rotation.x += sin(t * 2.6) * amount person.joints.spine.rotation.x += sin(t * 2.6 + 0.4) * amount * 0.6 ## Vira a cabeça (e um pouco o tronco) na direção de um ponto do mundo. func _look_head(person: Node3D, target: Vector3, amount := 1.0) -> void: var head: Node3D = person.joints.neck var local = person.global_transform.basis.inverse() * (target - head.global_position) var yaw = clampf(atan2(-local.x, -local.z), -1.4, 1.4) * amount person.joints.spine.rotation.y += yaw * 0.35 person.joints.neck.rotation.y += yaw * 0.65 func _seg(p: float, a: float, b: float) -> float: var q = clampf((p - a) / (b - a), 0.0, 1.0) return q * q * (3.0 - 2.0 * q) ## Barco na água: acompanha a altura e a inclinação das ondas em (x, z), proa para heading. func _boat_on_sea(pos: Vector3, heading: Vector3, t: float, rock := 0.6) -> void: var h = heading.normalized() var right = Vector3(-h.z, 0, h.x) var bow: float = _island.sea_height(pos.x + h.x * 3.5, pos.z + h.z * 3.5, t) var stern: float = _island.sea_height(pos.x - h.x * 3.5, pos.z - h.z * 3.5, t) var sr: float = _island.sea_height(pos.x + right.x * 1.2, pos.z + right.z * 1.2, t) var sl: float = _island.sea_height(pos.x - right.x * 1.2, pos.z - right.z * 1.2, t) _boat.position = Vector3(pos.x, (bow + stern + sr + sl) * 0.25, pos.z) _boat.rotation = Vector3(atan2(bow - stern, 7.0) * 0.8, atan2(-h.x, -h.z), atan2(sr - sl, 2.4) * 0.8) _boat.float_on(t, rock) ## Ponto do convés (coordenadas do barco) no mundo, já com o balanço deste quadro. func _on_boat(local: Vector3) -> Vector3: return _boat.deck().global_transform * local ## Nadador na superfície (corpo meio submerso), indo para heading. func _swim_at(person: Node3D, pos: Vector3, heading: Vector3, t: float, phase: float) -> void: var h = heading.normalized() person.basis = Basis(Vector3.UP, atan2(-h.x, -h.z)) person.position = Vector3(pos.x, _island.sea_height(pos.x, pos.z, t) - 0.06, pos.z) person.pose("swim", t * 0.85 + phase) # ------------------------------------------------------------------ momentos # Cada momento posiciona o elenco no instante t (p = t / duração). func _do_arrival(t: float, p: float) -> void: var e: Node3D = _people.elenilson var land = _spots.elenilson var water = land + _sea * 0.4 while water.distance_to(land) < 4.0 and _island.ground_at(water.x, water.z) > -0.55: water += _sea * 0.25 # 0–35%: nadando os últimos metros; 35–60%: apoia as mãos e sobe; depois, de joelhos. var k_up = _seg(p, 0.3, 0.62) var pos = water.lerp(land, _seg(p, 0.0, 0.6)) var swim_y: float = _island.sea_height(pos.x, pos.z, t) - 0.06 var y = lerpf(swim_y, _island.ground_at(land.x, land.z), k_up) y = maxf(y, _island.ground_at(pos.x, pos.z) - 0.35 * (1.0 - k_up)) _on_ground(e, pos, -_sea, 0.8 * k_up) e.position.y = y e.blend("swim", "kneel", lerpf(t * 0.8, 0.3, k_up), k_up) _breathe(e, t, 0.07 * k_up) e.joints.neck.rotation.x += 0.25 * k_up # cabeça baixa, recuperando o fôlego _place_group_resting(t, false) ## Os três companheiros descansando no costão (arrival e waiting). func _place_group_resting(t: float, night: bool) -> void: var ivan: Node3D = _people.ivan var manoel: Node3D = _people.manoel var iran: Node3D = _people.iranildo if night: _lie_on_ground(ivan, _spots.ivan, _tan) ivan.pose("lie", t) else: _on_ground(ivan, _spots.ivan, _sea.rotated(Vector3.UP, 0.4), 0.8) ivan.pose("kneel", t + 1.3) _breathe(ivan, t + 0.7, 0.06) ivan.joints.neck.rotation.x += 0.35 _lie_on_ground(manoel, _spots.manoel, -_tan) manoel.pose("lie", t + 0.9) _sit_on_rock(iran, _seats[1], _spots.iranildo, _sea.rotated(Vector3.UP, -0.3)) iran.pose("sit", t + 2.1) if night: iran.joints.neck.rotation.x += 0.45 # cochilando sentado func _do_waiting(t: float, p: float) -> void: # Noite → amanhecer → dia: o tempo da espera passando. _sky.blend_presets("night", "dawn", _seg(p, 0.4, 0.75)) if p > 0.75: _sky.blend_presets("dawn", "day", _seg(p, 0.75, 1.0)) var e: Node3D = _people.elenilson _sit_on_rock(e, _seats[0], _spots.elenilson, _sea) e.pose("sit", t) # Vigiando o horizonte: a cabeça varre o mar devagar. var scan = sin(p * PI * 1.6 + 0.3) * 0.5 _look_head(e, _spots.elenilson + _sea.rotated(Vector3.UP, scan) * 200.0 + Vector3(0, 1.0, 0)) _place_group_resting(t, true) func _do_sinking(t: float, p: float) -> void: var center = _c + _sea * 70.0 var k_sink = _seg(p, 0.3, 1.0) _boat.sink(k_sink * 0.95) _boat_on_sea(center, _tan, t, 1.6 + k_sink * 0.6) # Homens no convés, se segurando enquanto o barco aderna (coordenadas do barco). var places = { "elenilson": [Vector3(-0.55, Boat.DECK_Y, 1.5), 0.0], "ivan": [Vector3(0.45, Boat.DECK_Y, 1.9), 1.1], "manoel": [Vector3(-0.35, Boat.DECK_Y, 2.8), 2.3], "iranildo": [Vector3(0.55, Boat.DECK_Y, 3.0), 0.6], "crew_a": [Vector3(0.0, Boat.DECK_Y, 1.0), 1.7], "crew_b": [Vector3(-0.2, Boat.DECK_Y, -2.2), 2.9], } for id in places.keys(): var person: Node3D = _people[id] person.position = places[id][0] # Olhando para o lado que afunda (bombordo, -X do barco). person.rotation = Vector3(0, PI / 2.0 + float(places[id][1]) * 0.25 - 0.3, 0) person.blend("idle", "exhausted", t + float(places[id][1]), 0.35 + 0.5 * k_sink) func _do_swimming(t: float, p: float) -> void: # Mar escuro: os quatro nadam para a ilha (que aparece ao longe), Elenilson à frente. var heading = -_sea var start = _c + _sea * 46.0 var e_pos = start + heading * (4.0 * p) var formation = { "elenilson": [Vector3.ZERO, 0.0], "ivan": [_tan * 2.1 + _sea * 1.6, 1.3], "manoel": [-_tan * 1.9 + _sea * 2.7, 2.4], "iranildo": [_tan * 0.7 + _sea * 4.3, 0.7], } for id in formation.keys(): var drift = _tan * sin(t * 0.4 + float(formation[id][1])) * 0.25 _swim_at(_people[id], e_pos + formation[id][0] + drift, heading, t, float(formation[id][1])) func _do_rescue(t: float, p: float) -> void: # Lancha de mergulho chegando do mar; o grupo no costão acenando. var d0 = _c + _sea * 32.0 + _tan * 1.5 var d1 = _c + _sea * 18.0 + _tan * 1.0 var k_boat = 1.0 - pow(1.0 - p, 1.6) # desacelerando var bpos = d0.lerp(d1, k_boat) _boat_on_sea(bpos, (d1 - d0), t, 0.5) _place_divers_rescue(t) var e: Node3D = _people.elenilson # Elenilson se levanta (0–30%) e acena com o grupo. var k_up = _seg(p, 0.05, 0.3) var standing_spot: Vector3 = _ground(_spots.elenilson + _sea * 0.65) var seat: MeshInstance3D = _seats[0] if k_up < 1.0: _sit_on_rock(e, seat, _spots.elenilson, _sea) e.position = e.position.lerp(standing_spot, k_up) e.blend("sit", "idle", t, k_up) else: _on_ground(e, standing_spot, _sea) e.blend("idle", "wave", t, _seg(p, 0.3, 0.42)) seat.visible = true _seats[1].visible = false var waves = {"ivan": [0.08, 0.5], "manoel": [0.16, 1.7], "iranildo": [0.24, 2.6]} for id in waves.keys(): var person: Node3D = _people[id] var spot: Vector3 = _spots[id] _on_ground(person, spot, (bpos - spot) * Vector3(1, 0, 1)) person.blend("idle", "wave", t + float(waves[id][1]), _seg(p, float(waves[id][0]), float(waves[id][0]) + 0.15)) func _place_divers_rescue(t: float) -> void: var a: Node3D = _people.diver_a a.position = Vector3(0.3, Boat.DECK_Y, -2.2) a.rotation = Vector3.ZERO a.pose("wave", t + 0.4) var b: Node3D = _people.diver_b b.position = Vector3(-0.4, Boat.DECK_Y, 1.4) b.rotation = Vector3(0, -0.3, 0) b.pose("idle", t) func _do_boarding(t: float, p: float) -> void: var center: Vector3 = _c + _sea * 16.0 _boat_on_sea(center, _sea, t, 0.25) var diver: Node3D = _people.diver_a diver.position = Vector3(0.0, Boat.DECK_Y, 3.15) diver.rotation = Vector3(0, PI, 0) diver.pose("kneel", t) diver.joints.shoulder_l.rotation.x = 1.3 diver.joints.elbow_l.rotation.x = 0.2 var helm: Node3D = _people.diver_b helm.position = Vector3(-0.45, Boat.DECK_Y, 1.1) helm.rotation = Vector3(0, PI, 0) helm.pose("idle", t) _sit_on_boat(_people.ivan, -1.0, 1.7, t) _sit_on_boat(_people.manoel, 1.0, 1.7, t + 1.2) _board_person(_people.elenilson, t, p, 0.0, -1.0) _board_person(_people.iranildo, t, p, 0.22, 1.0) ## A subida é primeiro vertical, depois sobre a popa, mantendo o corpo fora do casco. ## Os dois últimos chegam em sequência; todos terminam sentados antes do fim da tomada. func _board_person(person: Node3D, t: float, p: float, delay: float, side: float) -> void: var q: float = clampf((p - delay) / 0.72, 0.0, 1.0) var shore: Vector3 = _c + _sea * 7.0 + _tan * side * 0.5 var stern: Vector3 = _on_boat(Vector3(side * 0.2, 0, 5.25)) var swim_pos: Vector3 = shore.lerp(stern, _seg(q, 0.0, 0.45)) var up: float = _seg(q, 0.45, 0.68) var aboard: float = _seg(q, 0.68, 0.84) var seat: Vector3 = _on_boat(Vector3(side * 0.86, Boat.DECK_Y + 0.02, 2.9)) var edge: Vector3 = _on_boat(Vector3(side * 0.2, Boat.DECK_Y + 0.12, 5.25)) var pos: Vector3 = swim_pos.lerp(edge, up).lerp(seat, aboard) var water_y: float = _island.sea_height(swim_pos.x, swim_pos.z, t) - 0.06 pos.y = lerpf(water_y, edge.y, up) pos.y = lerpf(pos.y, seat.y, aboard) person.position = pos var boat_basis: Basis = _boat.deck().global_basis.orthonormalized() person.basis = boat_basis * Basis(Vector3.UP, side * PI / 2.0 * aboard) if q < 0.68: person.blend("swim", "kneel", lerpf(t * 0.85, 0.3, up), up) else: person.blend("kneel", "sit", t, aboard) ## Sentado num banco da lancha (lado sx = -1 bombordo, 1 boreste), virado para o meio. func _sit_on_boat(person: Node3D, sx: float, z: float, t: float) -> void: if person.get_parent() != _boat.deck(): person.get_parent().remove_child(person) _boat.deck().add_child(person) person.position = Vector3(sx * 0.86, Boat.DECK_Y, z) person.rotation = Vector3(0, PI / 2.0 * sx, 0) person.pose("sit", t) func _do_departure(t: float, p: float) -> void: # A lancha se afasta da ilha; os quatro sentados, Elenilson olhando o costão. var start = _c + _sea * 16.0 var center = start + _sea * (16.0 * p) _boat_on_sea(center, _sea, t, 0.55) var helm: Node3D = _people.diver_b helm.position = Vector3(0.45, Boat.DECK_Y, 0.95) helm.rotation = Vector3(0, 0.15, 0) helm.pose("idle", t) var diver: Node3D = _people.diver_a diver.position = Vector3(-0.5, Boat.DECK_Y, 0.95) diver.rotation = Vector3(0, -0.2, 0) diver.pose("idle", t + 2.0) _sit_on_boat(_people.elenilson, -1.0, 2.9, t) _sit_on_boat(_people.ivan, -1.0, 1.75, t + 0.8) _sit_on_boat(_people.manoel, 1.0, 2.9, t + 1.6) _sit_on_boat(_people.iranildo, 1.0, 1.75, t + 2.4) for id in ["ivan", "manoel", "iranildo"]: (_people[id] as Node3D).joints.neck.rotation.x += 0.35 # cabeças baixas, em silêncio var e: Node3D = _people.elenilson _look_head(e, _c + Vector3(0, 2.0, 0)) ## Composição vertical centralizada no elenco. func _compose_shot(_t: float, p: float) -> Array: var e: Node3D = _people.elenilson var k: float = _seg(p, 0.0, 1.0) var angle: float = [0.0, -0.38, 0.42][posmod(_variant, 3)] var target: Vector3 var offset: Vector3 match _moment: "arrival": target = (e.position + Vector3(0, 0.5, 0)).lerp(_c + Vector3(0, 0.7, 0), k) offset = (_sea * lerpf(6.0, 11.5, k) + _tan * 2.0).rotated(Vector3.UP, angle) + Vector3(0, lerpf(2.0, 4.0, k), 0) "waiting": target = _c + Vector3(0, 0.65, 0) offset = (_sea * 9.8 + _tan * lerpf(3.0, 2.2, k)).rotated(Vector3.UP, angle) + Vector3(0, 3.3, 0) "swimming": target = e.position + _sea * 1.2 + Vector3(0, 0.1, 0) offset = (-_sea * 9.5 + _tan * 3.5).rotated(Vector3.UP, angle) + Vector3(0, 3.8 + 0.3 * k, 0) "rescue": target = _c + _sea * 4.0 + Vector3(0, 0.8, 0) offset = (-_sea * 15.0 + _tan * 0.6).rotated(Vector3.UP, angle * 0.12) + Vector3(0, 7.5, 0) "boarding": target = _on_boat(Vector3(0, 0.8, 2.8)) offset = _boat.basis * Vector3(13.0 if _variant % 2 == 0 else -13.0, 7.0 + float(_variant % 3), 10.0) "departure": target = _on_boat(Vector3(0, 1.2, 1.8)) offset = _boat.basis * Vector3(6.0 if _variant % 2 == 0 else -6.0, 7.0 + float(_variant % 3) * 0.6, -11.0 - k * 2.0) _: target = _boat.position + Vector3(0, 0.8 - _seg(p, 0.3, 1.0) * 0.8, 0) offset = (_sea * 22.0 + _tan * 3.0).rotated(Vector3.UP, angle) + Vector3(0, 4.0 + float(_variant % 3), 0) return [target + offset, target, target] func _place_camera(pos: Vector3, target: Vector3, _focus: Vector3, t: float) -> void: var direction: Vector3 = (pos - target).normalized() var view_basis: Basis = Basis.looking_at(-direction, Vector3.UP) var required: float = pos.distance_to(target) # Enquadra as peças articuladas em x=8–92%, y=18–72%, inclusive durante a subida. for id in ["elenilson", "ivan", "manoel", "iranildo"]: for part in _support_points[id]: var mesh: MeshInstance3D = part[0] var bounds: AABB = mesh.mesh.get_aabb() for corner in 8: required = maxf(required, _required_distance(mesh.global_transform * bounds.get_endpoint(corner), target, view_basis)) if _boat and _moment != "rescue": for x in [-1.4, 1.4]: for y in [-0.7, 4.1]: for z in [-4.1, 4.1]: required = maxf(required, _required_distance(_on_boat(Vector3(x, y, z)), target, view_basis)) var cam: Vector3 = target + direction * required * _zoom # Nunca dentro da pedra nem da água. cam.y = maxf(cam.y, _island.ground_at(cam.x, cam.z) + 0.4) cam.y = maxf(cam.y, _island.sea_height(cam.x, cam.z, t) + 0.3) _camera.position = cam _camera.look_at(target, Vector3.UP) _island.set_sea_focus(cam.x, cam.z) _last_cam = cam func _required_distance(point: Vector3, target: Vector3, view_basis: Basis) -> float: var local: Vector3 = view_basis.inverse() * (point - target) var tangent: float = tan(deg_to_rad(_camera.fov * 0.5)) var horizontal: float = absf(local.x) / (tangent * (9.0 / 16.0) * 0.84) var vertical: float = maxf(local.y / (tangent * 0.64), -local.y / (tangent * 0.44)) return local.z + maxf(horizontal, vertical)