479 lines
13 KiB
GDScript
479 lines
13 KiB
GDScript
class_name FishingPresentation
|
|
extends Node3D
|
|
|
|
signal cast_completed
|
|
signal outcome_completed(outcome: StringName)
|
|
|
|
enum VisualMode {
|
|
NONE,
|
|
AIMING,
|
|
CASTING,
|
|
FISHING,
|
|
OUTCOME,
|
|
}
|
|
|
|
enum LineMode {
|
|
HIDDEN,
|
|
TAUT,
|
|
SLACK,
|
|
}
|
|
|
|
@export_category("Water")
|
|
@export var water_surface_offset_y: float = -0.72
|
|
@export_range(0.1, 10.0, 0.1) var pickup_distance_from_player: float = 5.5
|
|
|
|
@export_category("Fishing Line")
|
|
@export_range(0.0, 0.5, 0.01) var slack_amount: float = 0.08
|
|
@export_range(0.0, 2.0, 0.01) var minimum_slack: float = 0.08
|
|
@export_range(0.0, 3.0, 0.01) var maximum_slack: float = 0.65
|
|
@export_range(2, 20, 1) var sag_interpolation_count: int = 8
|
|
@export_range(0.1, 30.0, 0.1) var line_transition_speed: float = 7.0
|
|
|
|
@export_category("Cast")
|
|
@export_range(0.1, 30.0, 0.1) var target_movement_smoothing: float = 14.0
|
|
@export_range(0.1, 3.0, 0.05) var cast_travel_duration: float = 0.65
|
|
@export_range(0.1, 5.0, 0.1) var cast_arc_height: float = 2.0
|
|
@export_range(0.0, 90.0, 1.0) var maximum_rod_cock_degrees: float = 50.0
|
|
@export_range(0.0, 60.0, 1.0) var rod_forward_swing_degrees: float = 22.0
|
|
@export_range(0.05, 1.0, 0.01) var rod_forward_swing_duration: float = 0.12
|
|
@export_range(0.05, 1.0, 0.01) var rod_recovery_duration: float = 0.22
|
|
@export var valid_target_material: Material
|
|
@export var invalid_target_material: Material
|
|
|
|
@onready var _target_marker: MeshInstance3D = %CastTargetMarker
|
|
@onready var _invalid_cross_a: MeshInstance3D = %InvalidCrossA
|
|
@onready var _invalid_cross_b: MeshInstance3D = %InvalidCrossB
|
|
@onready var _bobber: MeshInstance3D = %Bobber
|
|
@onready var _line: MeshInstance3D = %FishingLine
|
|
|
|
var _mode: VisualMode = VisualMode.NONE
|
|
var _line_mode: LineMode = LineMode.HIDDEN
|
|
var _line_mesh: ImmediateMesh = ImmediateMesh.new()
|
|
var _current_sag: float = 0.0
|
|
var _rod: Node3D
|
|
var _rod_tip: Marker3D
|
|
var _rod_neutral_rotation: Vector3
|
|
var _target_goal: Vector3
|
|
var _cast_position: Vector3
|
|
var _pickup_position: Vector3
|
|
var _active_tween: Tween
|
|
var _rod_tween: Tween
|
|
var _bite_tween: Tween
|
|
var _default_water_surface_offset_y: float
|
|
|
|
|
|
func _ready() -> void:
|
|
_default_water_surface_offset_y = water_surface_offset_y
|
|
_line.mesh = _line_mesh
|
|
cleanup()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if _mode == VisualMode.AIMING:
|
|
var weight: float = 1.0 - exp(-target_movement_smoothing * delta)
|
|
_target_marker.global_position = _target_marker.global_position.lerp(
|
|
_target_goal,
|
|
weight
|
|
)
|
|
if _line_mode != LineMode.HIDDEN:
|
|
_update_line(delta)
|
|
|
|
|
|
func get_water_surface_height() -> float:
|
|
return global_position.y + water_surface_offset_y
|
|
|
|
|
|
func set_water_surface_height(surface_height: float) -> void:
|
|
water_surface_offset_y = surface_height - global_position.y
|
|
|
|
|
|
func reset_water_surface_height() -> void:
|
|
water_surface_offset_y = _default_water_surface_offset_y
|
|
|
|
|
|
func set_line_mode(mode: LineMode) -> void:
|
|
_line_mode = mode
|
|
_line.visible = mode != LineMode.HIDDEN
|
|
if mode == LineMode.HIDDEN:
|
|
_current_sag = 0.0
|
|
_line_mesh.clear_surfaces()
|
|
|
|
|
|
func begin_aim(
|
|
rod_tip: Marker3D,
|
|
rod: Node3D,
|
|
minimum_target: Vector3,
|
|
target_is_fishable: bool,
|
|
) -> void:
|
|
cleanup()
|
|
if rod_tip == null or rod == null:
|
|
return
|
|
|
|
_mode = VisualMode.AIMING
|
|
_rod = rod
|
|
_rod_tip = rod_tip
|
|
_rod_neutral_rotation = _rod.rotation
|
|
_target_goal = minimum_target
|
|
_target_marker.global_position = minimum_target
|
|
_target_marker.scale = Vector3.ONE
|
|
_target_marker.visible = true
|
|
_set_target_validity(target_is_fishable)
|
|
|
|
|
|
func update_rod_charge(charge: float) -> void:
|
|
if _mode != VisualMode.AIMING or _rod == null:
|
|
return
|
|
|
|
var cock_rotation: Vector3 = _rod_neutral_rotation
|
|
cock_rotation.x += deg_to_rad(maximum_rod_cock_degrees) * clampf(charge, 0.0, 1.0)
|
|
_rod.rotation = cock_rotation
|
|
|
|
|
|
func update_aim_target(
|
|
target: Vector3,
|
|
charge: float,
|
|
target_is_fishable: bool,
|
|
) -> void:
|
|
if _mode != VisualMode.AIMING:
|
|
return
|
|
|
|
_target_goal = target
|
|
var maximum_response: float = smoothstep(0.9, 1.0, clampf(charge, 0.0, 1.0))
|
|
_target_marker.scale = Vector3.ONE * lerpf(1.0, 1.15, maximum_response)
|
|
_set_target_validity(target_is_fishable)
|
|
|
|
|
|
func begin_cast(target: Vector3) -> void:
|
|
if _mode != VisualMode.AIMING or _rod_tip == null:
|
|
return
|
|
|
|
_kill_active_tween()
|
|
_mode = VisualMode.CASTING
|
|
_target_marker.visible = false
|
|
_bobber.visible = true
|
|
_bobber.scale = Vector3.ONE
|
|
_cast_position = _with_water_height(target)
|
|
_pickup_position = _calculate_pickup_position(_cast_position)
|
|
|
|
var cast_start: Vector3 = _rod_tip.global_position
|
|
_bobber.global_position = cast_start
|
|
_begin_rod_release()
|
|
_active_tween = create_tween()
|
|
_active_tween.set_trans(Tween.TRANS_SINE)
|
|
_active_tween.set_ease(Tween.EASE_IN_OUT)
|
|
_active_tween.tween_method(
|
|
_set_cast_sample.bind(cast_start, _cast_position),
|
|
0.0,
|
|
1.0,
|
|
cast_travel_duration
|
|
)
|
|
_active_tween.finished.connect(_on_cast_tween_finished)
|
|
|
|
|
|
func show_bite() -> void:
|
|
if _mode != VisualMode.FISHING:
|
|
return
|
|
|
|
_kill_bite_tween()
|
|
_bobber.scale = Vector3.ONE
|
|
_bite_tween = create_tween()
|
|
_bite_tween.set_trans(Tween.TRANS_QUAD)
|
|
_bite_tween.set_ease(Tween.EASE_IN_OUT)
|
|
_bite_tween.tween_property(
|
|
_bobber,
|
|
"scale",
|
|
Vector3.ONE * 0.68,
|
|
0.08
|
|
)
|
|
_bite_tween.tween_property(
|
|
_bobber,
|
|
"scale",
|
|
Vector3.ONE * 1.2,
|
|
0.1
|
|
)
|
|
_bite_tween.tween_property(
|
|
_bobber,
|
|
"scale",
|
|
Vector3.ONE,
|
|
0.1
|
|
)
|
|
_bite_tween.finished.connect(_on_bite_tween_finished)
|
|
|
|
|
|
func show_withdrawal_position(world_position: Vector3) -> void:
|
|
if _mode != VisualMode.FISHING:
|
|
return
|
|
|
|
_kill_active_tween()
|
|
_bobber.global_position = _with_water_height(world_position)
|
|
|
|
|
|
func begin_reeling() -> void:
|
|
if _mode != VisualMode.FISHING:
|
|
return
|
|
|
|
_kill_active_tween()
|
|
_cast_position = _with_water_height(_bobber.global_position)
|
|
|
|
|
|
func show_reel_position(world_position: Vector3, _input_held: bool) -> void:
|
|
if _mode != VisualMode.FISHING:
|
|
return
|
|
|
|
_kill_active_tween()
|
|
_bobber.global_position = _with_water_height(world_position)
|
|
|
|
|
|
func play_outcome(outcome: StringName) -> void:
|
|
if _mode == VisualMode.NONE:
|
|
cleanup()
|
|
# Gameplay completion must not depend on a presentation tween still
|
|
# being active. The caller owns idempotency for the outcome.
|
|
outcome_completed.emit(outcome)
|
|
return
|
|
|
|
_kill_active_tween()
|
|
_kill_bite_tween()
|
|
_kill_rod_tween()
|
|
_restore_rod_neutral()
|
|
_mode = VisualMode.OUTCOME
|
|
_active_tween = create_tween()
|
|
_active_tween.set_trans(Tween.TRANS_QUAD)
|
|
_active_tween.set_ease(Tween.EASE_IN)
|
|
|
|
if _target_marker.visible and not _bobber.visible:
|
|
_active_tween.tween_property(_target_marker, "scale", Vector3.ZERO, 0.18)
|
|
else:
|
|
_target_marker.visible = false
|
|
match outcome:
|
|
&"catch":
|
|
var catch_target: Vector3 = _bobber.global_position
|
|
if _rod_tip != null:
|
|
catch_target = _rod_tip.global_position
|
|
_active_tween.set_parallel(true)
|
|
_active_tween.tween_property(_bobber, "global_position", catch_target, 0.35)
|
|
_active_tween.tween_property(_bobber, "scale", Vector3.ZERO, 0.35)
|
|
&"escape":
|
|
var start_x: float = _bobber.global_position.x
|
|
_active_tween.tween_property(
|
|
_bobber,
|
|
"global_position:x",
|
|
start_x - 0.18,
|
|
0.08
|
|
)
|
|
_active_tween.tween_property(
|
|
_bobber,
|
|
"global_position:x",
|
|
start_x + 0.18,
|
|
0.08
|
|
)
|
|
_active_tween.tween_property(
|
|
_bobber,
|
|
"global_position:y",
|
|
get_water_surface_height() - 0.4,
|
|
0.2
|
|
)
|
|
&"invalid":
|
|
var return_target: Vector3 = _bobber.global_position
|
|
if _rod_tip != null:
|
|
return_target = _rod_tip.global_position
|
|
_active_tween.set_parallel(true)
|
|
_active_tween.tween_property(_bobber, "global_position", return_target, 0.28)
|
|
_active_tween.tween_property(_bobber, "scale", Vector3.ZERO, 0.28)
|
|
&"withdrawal":
|
|
var withdrawal_target: Vector3 = _bobber.global_position
|
|
if _rod_tip != null:
|
|
withdrawal_target = _rod_tip.global_position
|
|
_active_tween.set_parallel(true)
|
|
_active_tween.tween_property(
|
|
_bobber,
|
|
"global_position",
|
|
withdrawal_target,
|
|
0.28
|
|
)
|
|
_active_tween.tween_property(_bobber, "scale", Vector3.ZERO, 0.28)
|
|
_:
|
|
_active_tween.tween_property(_bobber, "scale", Vector3.ZERO, 0.18)
|
|
|
|
_active_tween.finished.connect(_on_outcome_finished.bind(outcome))
|
|
|
|
|
|
func cleanup() -> void:
|
|
_kill_active_tween()
|
|
_kill_bite_tween()
|
|
_kill_rod_tween()
|
|
_restore_rod_neutral()
|
|
_mode = VisualMode.NONE
|
|
_rod = null
|
|
_rod_tip = null
|
|
_target_marker.visible = false
|
|
_target_marker.scale = Vector3.ONE
|
|
_invalid_cross_a.visible = false
|
|
_invalid_cross_b.visible = false
|
|
_bobber.visible = false
|
|
_bobber.scale = Vector3.ONE
|
|
set_line_mode(LineMode.HIDDEN)
|
|
|
|
|
|
func _on_outcome_finished(outcome: StringName) -> void:
|
|
cleanup()
|
|
outcome_completed.emit(outcome)
|
|
|
|
|
|
func _set_cast_sample(
|
|
progress: float,
|
|
start: Vector3,
|
|
target: Vector3,
|
|
) -> void:
|
|
var sample: Vector3 = start.lerp(target, progress)
|
|
sample.y += sin(progress * PI) * cast_arc_height
|
|
_bobber.global_position = sample
|
|
|
|
|
|
func _on_cast_tween_finished() -> void:
|
|
if _mode != VisualMode.CASTING:
|
|
return
|
|
|
|
_active_tween = null
|
|
_bobber.global_position = _cast_position
|
|
_mode = VisualMode.FISHING
|
|
cast_completed.emit()
|
|
|
|
|
|
func _calculate_pickup_position(target: Vector3) -> Vector3:
|
|
var player_on_water: Vector3 = target
|
|
if _rod_tip != null:
|
|
player_on_water = _with_water_height(_rod_tip.global_position)
|
|
var outward: Vector3 = target - player_on_water
|
|
outward.y = 0.0
|
|
if outward.is_zero_approx():
|
|
outward = Vector3.FORWARD
|
|
else:
|
|
outward = outward.normalized()
|
|
var target_distance: float = player_on_water.distance_to(target)
|
|
var pickup_distance: float = minf(
|
|
pickup_distance_from_player,
|
|
target_distance * 0.8
|
|
)
|
|
return player_on_water + outward * pickup_distance
|
|
|
|
|
|
func _with_water_height(world_position: Vector3) -> Vector3:
|
|
return Vector3(
|
|
world_position.x,
|
|
get_water_surface_height(),
|
|
world_position.z,
|
|
)
|
|
|
|
|
|
func _update_line(delta: float) -> void:
|
|
if _rod_tip == null or not is_instance_valid(_rod_tip):
|
|
cleanup()
|
|
return
|
|
|
|
var rod_tip_position: Vector3 = _rod_tip.global_position
|
|
var bobber_position: Vector3 = _bobber.global_position
|
|
var target_sag: float = 0.0
|
|
if _line_mode == LineMode.SLACK:
|
|
var line_length: float = rod_tip_position.distance_to(bobber_position)
|
|
target_sag = clampf(
|
|
line_length * slack_amount,
|
|
minimum_slack,
|
|
maximum_slack
|
|
)
|
|
var sag_weight: float = 1.0 - exp(-line_transition_speed * delta)
|
|
_current_sag = lerpf(_current_sag, target_sag, sag_weight)
|
|
var rendered_points: PackedVector3Array = _build_sagged_line_points(
|
|
rod_tip_position,
|
|
bobber_position,
|
|
_current_sag,
|
|
)
|
|
|
|
_line_mesh.clear_surfaces()
|
|
if rendered_points.size() < 2:
|
|
return
|
|
_line_mesh.surface_begin(Mesh.PRIMITIVE_LINES)
|
|
for point_index: int in range(1, rendered_points.size()):
|
|
_line_mesh.surface_add_vertex(to_local(rendered_points[point_index - 1]))
|
|
_line_mesh.surface_add_vertex(to_local(rendered_points[point_index]))
|
|
_line_mesh.surface_end()
|
|
|
|
|
|
func _build_sagged_line_points(
|
|
start: Vector3,
|
|
end: Vector3,
|
|
sag: float,
|
|
) -> PackedVector3Array:
|
|
var points := PackedVector3Array()
|
|
var subdivisions: int = 1 if sag <= 0.001 else sag_interpolation_count
|
|
points.append(start)
|
|
for step: int in range(1, subdivisions + 1):
|
|
var progress: float = float(step) / float(subdivisions)
|
|
var point: Vector3 = start.lerp(end, progress)
|
|
if step < subdivisions and sag > 0.0:
|
|
point.y -= 4.0 * progress * (1.0 - progress) * sag
|
|
points.append(point)
|
|
return points
|
|
|
|
|
|
func _begin_rod_release() -> void:
|
|
_kill_rod_tween()
|
|
if _rod == null:
|
|
return
|
|
|
|
var forward_rotation: Vector3 = _rod_neutral_rotation
|
|
forward_rotation.x -= deg_to_rad(rod_forward_swing_degrees)
|
|
_rod_tween = create_tween()
|
|
_rod_tween.set_trans(Tween.TRANS_QUAD)
|
|
_rod_tween.set_ease(Tween.EASE_OUT)
|
|
_rod_tween.tween_property(
|
|
_rod,
|
|
"rotation",
|
|
forward_rotation,
|
|
rod_forward_swing_duration
|
|
)
|
|
_rod_tween.set_ease(Tween.EASE_IN_OUT)
|
|
_rod_tween.tween_property(
|
|
_rod,
|
|
"rotation",
|
|
_rod_neutral_rotation,
|
|
rod_recovery_duration
|
|
)
|
|
|
|
|
|
func _restore_rod_neutral() -> void:
|
|
if _rod != null and is_instance_valid(_rod):
|
|
_rod.rotation = _rod_neutral_rotation
|
|
|
|
|
|
func _set_target_validity(target_is_fishable: bool) -> void:
|
|
if target_is_fishable:
|
|
_target_marker.material_override = valid_target_material
|
|
else:
|
|
_target_marker.material_override = invalid_target_material
|
|
_invalid_cross_a.visible = not target_is_fishable
|
|
_invalid_cross_b.visible = not target_is_fishable
|
|
|
|
|
|
func _kill_active_tween() -> void:
|
|
if _active_tween != null and _active_tween.is_valid():
|
|
_active_tween.kill()
|
|
_active_tween = null
|
|
|
|
|
|
func _kill_bite_tween() -> void:
|
|
if _bite_tween != null and _bite_tween.is_valid():
|
|
_bite_tween.kill()
|
|
_bite_tween = null
|
|
if is_instance_valid(_bobber):
|
|
_bobber.scale = Vector3.ONE
|
|
|
|
|
|
func _on_bite_tween_finished() -> void:
|
|
_bite_tween = null
|
|
|
|
|
|
func _kill_rod_tween() -> void:
|
|
if _rod_tween != null and _rod_tween.is_valid():
|
|
_rod_tween.kill()
|
|
_rod_tween = null
|