Restructure into core/ and content/official/
This commit is contained in:
Johan Sandoval
@@ -0,0 +1,192 @@
|
||||
class_name Dart
|
||||
extends RigidBody3D
|
||||
|
||||
## A single dart. Dragged from the tray, thrown at the board.
|
||||
##
|
||||
## Lifecycle: FROZEN -> DRAGGING -> IN_FLIGHT -> LANDED
|
||||
## The scene root (main.gd) routes mouse input here; the dart does not
|
||||
## hunt for the camera or raycast for itself.
|
||||
|
||||
signal landed(dart: Dart, hit_point: Vector3)
|
||||
|
||||
enum State { IDLE, DRAGGING, IN_FLIGHT, LANDED }
|
||||
|
||||
# --- Tuning -------------------------------------------------------------
|
||||
|
||||
@export_group("Drag")
|
||||
## How hard the dart chases the cursor while held.
|
||||
@export var drag_follow_speed: float = 20.0
|
||||
## Clamp so a fast flick doesn't launch it across the room mid-drag.
|
||||
@export var max_drag_speed: float = 42.0
|
||||
## Tilt of the drag plane relative to the camera, in degrees.
|
||||
@export_range(-180.0, 180.0) var drag_plane_angle: float = 15.0
|
||||
@export var drag_linear_damp: float = 5.0
|
||||
@export var drag_angular_damp: float = 10.0
|
||||
|
||||
@export_group("Throw")
|
||||
@export var forward_impulse: float = 8.0
|
||||
|
||||
## Scale the raw flick velocity down. Raw mouse speed is usually too fast.
|
||||
@export var throw_force_multiplier: float = 0.5
|
||||
@export var max_throw_speed: float = 42.0
|
||||
## Higher = more visible arc. Real gravity looks too floaty at dart scale.
|
||||
@export var flight_gravity_scale: float = 2.0
|
||||
|
||||
@export_group("Flight")
|
||||
## How fast the nose swings to face the direction of travel.
|
||||
@export var nose_align_speed: float = 1.0
|
||||
## Which local axis is the dart's tip. Check this against the model.
|
||||
@export var forward_axis: Vector3 = Vector3.FORWARD
|
||||
## Below this speed the dart is considered landed.
|
||||
@export var landed_speed_threshold: float = 0.5
|
||||
|
||||
# --- State --------------------------------------------------------------
|
||||
|
||||
var state: State = State.IDLE
|
||||
|
||||
var _drag_plane: Plane
|
||||
var _drag_offset: Vector3 = Vector3.ZERO
|
||||
var _target_pos: Vector3 = Vector3.ZERO
|
||||
|
||||
## Sampled positions, used to compute throw velocity on release.
|
||||
const HISTORY_LENGTH := 6
|
||||
var _pos_history: Array[Vector3] = []
|
||||
var _time_history: Array[float] = []
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
freeze_mode = RigidBody3D.FREEZE_MODE_STATIC
|
||||
freeze = true
|
||||
add_to_group(&"dart")
|
||||
|
||||
|
||||
# --- Public API (called by main.gd) --------------------------------------
|
||||
|
||||
func begin_drag(camera: Camera3D, hit_point: Vector3) -> void:
|
||||
state = State.DRAGGING
|
||||
freeze = false
|
||||
|
||||
gravity_scale = 0.0 # don't sag while held
|
||||
linear_damp = drag_linear_damp
|
||||
angular_damp = drag_angular_damp
|
||||
|
||||
# The plane the dart slides along while dragged. Tilted off the camera's
|
||||
# view axis so pulling back also pulls the dart down, which feels natural.
|
||||
var base_normal := camera.global_transform.basis.z
|
||||
var tilted := base_normal.rotated(
|
||||
camera.global_transform.basis.x,
|
||||
deg_to_rad(drag_plane_angle)
|
||||
)
|
||||
_drag_plane = Plane(tilted.normalized(), hit_point)
|
||||
_drag_offset = global_position - hit_point
|
||||
|
||||
# Seed the target to the current position. Without this the dart drops
|
||||
# to the plane origin until the mouse first moves.
|
||||
_target_pos = global_position
|
||||
|
||||
_pos_history.clear()
|
||||
_time_history.clear()
|
||||
|
||||
|
||||
func update_drag(camera: Camera3D, mouse_pos: Vector2) -> void:
|
||||
if state != State.DRAGGING:
|
||||
return
|
||||
|
||||
var ray_origin := camera.project_ray_origin(mouse_pos)
|
||||
var ray_dir := camera.project_ray_normal(mouse_pos)
|
||||
var hit = _drag_plane.intersects_ray(ray_origin, ray_dir)
|
||||
if hit != null:
|
||||
_target_pos = hit + _drag_offset
|
||||
|
||||
func release_drag() -> void:
|
||||
if state != State.DRAGGING:
|
||||
return
|
||||
state = State.IN_FLIGHT
|
||||
gravity_scale = flight_gravity_scale
|
||||
linear_damp = 0.0
|
||||
angular_damp = 0.0
|
||||
|
||||
# The flick gives aim (up/down/left/right). It CANNOT give forward speed —
|
||||
# the drag plane faces the camera, so motion toward the board is ~zero.
|
||||
var flick := _calculate_throw_velocity() * throw_force_multiplier
|
||||
|
||||
# The forward component has to come from somewhere. Use the camera's
|
||||
# forward, so "throw" always means "toward what you're looking at".
|
||||
var cam := get_viewport().get_camera_3d()
|
||||
var forward := -cam.global_transform.basis.z * forward_impulse
|
||||
|
||||
var throw := flick + forward
|
||||
if throw.length() > max_throw_speed:
|
||||
throw = throw.normalized() * max_throw_speed
|
||||
linear_velocity = throw
|
||||
|
||||
var raw := _calculate_throw_velocity()
|
||||
print("flick: %s forward: %s final: %s (%.1f m/s)" % [flick, forward, throw, throw.length()])
|
||||
|
||||
|
||||
# --- Physics ------------------------------------------------------------
|
||||
|
||||
func _physics_process(delta: float) -> void:
|
||||
match state:
|
||||
State.DRAGGING:
|
||||
_process_drag()
|
||||
State.IN_FLIGHT:
|
||||
_process_flight(delta)
|
||||
|
||||
|
||||
func _process_drag() -> void:
|
||||
# Chase the target with velocity rather than teleporting, so the dart
|
||||
# still collides with things and carries momentum into the throw.
|
||||
var to_target := _target_pos - global_position
|
||||
var desired := to_target * drag_follow_speed
|
||||
if desired.length() > max_drag_speed:
|
||||
desired = desired.normalized() * max_drag_speed
|
||||
|
||||
linear_velocity = desired
|
||||
angular_velocity = angular_velocity.lerp(Vector3.ZERO, 0.2)
|
||||
|
||||
_pos_history.append(global_position)
|
||||
_time_history.append(Time.get_ticks_msec() / 1000.0)
|
||||
if _pos_history.size() > HISTORY_LENGTH:
|
||||
_pos_history.pop_front()
|
||||
_time_history.pop_front()
|
||||
|
||||
|
||||
func _process_flight(delta: float) -> void:
|
||||
if linear_velocity.length() > landed_speed_threshold:
|
||||
_align_to_velocity(delta)
|
||||
else:
|
||||
_on_landed()
|
||||
|
||||
|
||||
func _align_to_velocity(delta: float) -> void:
|
||||
var vel_dir := linear_velocity.normalized()
|
||||
var current_forward := global_transform.basis * forward_axis
|
||||
var axis := current_forward.cross(vel_dir)
|
||||
|
||||
if axis.length() < 0.001:
|
||||
return # already aligned, or exactly opposed
|
||||
|
||||
axis = axis.normalized()
|
||||
var angle := current_forward.angle_to(vel_dir)
|
||||
var step := minf(angle, nose_align_speed * delta)
|
||||
|
||||
global_transform.basis = global_transform.basis.rotated(axis, step)
|
||||
global_transform.basis = global_transform.basis.orthonormalized()
|
||||
|
||||
|
||||
func _on_landed() -> void:
|
||||
state = State.LANDED
|
||||
angular_velocity = Vector3.ZERO
|
||||
landed.emit(self, global_position)
|
||||
|
||||
|
||||
func _calculate_throw_velocity() -> Vector3:
|
||||
if _pos_history.size() < 2:
|
||||
return linear_velocity
|
||||
|
||||
var dt: float = _time_history[-1] - _time_history[0]
|
||||
if dt <= 0.0:
|
||||
return linear_velocity
|
||||
|
||||
return (_pos_history[-1] - _pos_history[0]) / dt
|
||||
Reference in New Issue
Block a user