saucer.gd

extends Target


export var _bullet_scene : PackedScene

export var _firing_timer_path : NodePath
onready var _firing_timer := get_node(_firing_timer_path) as Timer
onready var _original_firing_time := _firing_timer.wait_time

export var _speed = 100.0
export var _wander_spacing := 100.0
export var _wander_offset := 50.0
export var _close_enough_distance := 5.0

export var _fire_at_player_probability := 0.5
export var _firing_timer_variation := 0.5

enum State {
	HEADING_IN,
	MILLING_AROUND,
	HEADING_OUT
}

var _current_state : int = State.HEADING_IN
var _target_point : Vector2
var _wander_point : Vector2
var _is_steering_left := false


func _ready() -> void:
	position = Globals.random_point_on_edge_of_screen()		# Perhaps should be set by the spawner.
	_pick_new_target_point()
	_wander_point = position


func _physics_process(delta: float) -> void:
	position = position.move_toward(_wander_point, _speed * delta)
	
	if _is_close_enough(_target_point):
		match _current_state:
			State.HEADING_IN:
				_pick_new_target_point()
				_current_state = State.MILLING_AROUND
				_firing_timer.start()
			State.MILLING_AROUND:
				_target_point = Globals.random_point_on_edge_of_screen()
				_current_state = State.HEADING_OUT
			State.HEADING_OUT:
				queue_free()
	elif _is_close_enough(_wander_point):
		_pick_new_wander_point()
	
#	update()


func _pick_new_target_point() -> void:
	_target_point = Globals.random_point_on_screen(0.2)


func _pick_new_wander_point() -> void:
	if position.distance_squared_to(_target_point) < _wander_spacing * _wander_spacing * 1.1:
		_wander_point = _target_point
		return

	var direction := position.direction_to(_target_point)
	_wander_point = position + direction * _wander_spacing + direction.rotated(-90.0 if _is_steering_left else 90.0) * _wander_offset
	_is_steering_left = not _is_steering_left


func _is_close_enough(point : Vector2) -> bool:
	return (position.distance_squared_to(point) < _close_enough_distance)


#func _draw() -> void:
#	draw_circle(_target_point - position, 5.0, Color.green)
#	draw_circle(_wander_point - position, 5.0, Color.yellow)


func _on_firing_timeout() -> void:
	var bullet := _bullet_scene.instance() as Bullet
	bullet.position = position
	
	var player := Globals.game.player
	if is_instance_valid(player) and randf() < _fire_at_player_probability:
		# Sometimes fire at player if they're around:
		var direction = position.direction_to(player.position)
		bullet.rotation = atan2(direction.x, -direction.y)
	else:
		# Fire in a random direction:
		bullet.rotation = randf() * PI * 2.0
	
	get_parent().add_child(bullet)
	_firing_timer.wait_time = _original_firing_time + randf() * _firing_timer_variation
	_firing_timer.start()