odyssey-old/Scenes/UI/SpaceMapInside.gd

extends Control

export var cell_size = 100
export var bgzoom = 50

const BORDER_WIDTH = 4
const BORDER_LENGTH = 30
const RADAR_EFFECT_DELAY = 1

export(Texture) var background
export(Font) var font

var dragging = false
var origin = Vector2.ZERO
var last_origin = origin
var last_mouse_pos = Vector2.ZERO
var set_position = true
var radar_next_remaining = RADAR_EFFECT_DELAY

onready var scene = $"/root/scene"
onready var speed_text = $"../HBoxContainer/HBoxContainer/CurrentSpeed"
onready var dir_text = $"../HBoxContainer/HBoxContainer/CurrentAngle"

var last_pos = []

func _physics_process(delta):
	radar_next_remaining -= delta
	if radar_next_remaining < 0:
		var current_position = (scene.world.map.current_ship_position + scene.world.map.current_ship_subpos) * 100
		last_pos.append(current_position)
		if last_pos.size() > 20:
			last_pos.pop_front()
		radar_next_remaining = RADAR_EFFECT_DELAY
	if not visible:
		return
	speed_text.text = str(round(scene.world.map.current_ship_speed * 10000)) + " u/s"
	dir_text.text = str(round(rad2deg(scene.world.map.current_ship_direction))) + " deg"
	update()

func _draw():
	var win_size = get_global_rect().size
	var current_position = (scene.world.map.current_ship_position + scene.world.map.current_ship_subpos) * 100
	if set_position:
		origin = current_position - win_size/2.0
		last_origin = origin
	if win_size.x > 0:
		set_position = false
	var cols = int(ceil(win_size.x/cell_size))
	var rows = int(ceil(win_size.y/cell_size))
	var xoffset = float(int(origin.x) % cell_size)
	var yoffset = float(int(origin.y) % cell_size)
	draw_texture_rect_region(background, Rect2(Vector2.ZERO, win_size), Rect2(origin*bgzoom, win_size*bgzoom), Color(0.5,0.5,0.5,1))
	for i in range(0, cols+1):
		draw_line(Vector2(i * cell_size-xoffset, 0), Vector2(i * cell_size-xoffset, win_size.y), Color.white * 0.5)
	for i in range(0, rows):
		draw_line(Vector2(0, i * cell_size-yoffset), Vector2(win_size.x, i * cell_size-yoffset), Color.white * 0.5)
	for x in range(-1, cols+1):
		for y in range(-1, rows+1):
			var real_x = x + int(origin.x/cell_size)
			var real_y = y + int(origin.y/cell_size)
			var sector_name = Coordinates.as_string(Vector2(real_x, real_y))
			draw_string(font, Vector2(x * cell_size + 6 - xoffset, y * cell_size + 20 - yoffset), sector_name, Color(1,1,1,0.5))

	var viewport = Rect2(origin, win_size)

	var point_count = last_pos.size()
	for pos_index in range(0, point_count):
		draw_circle(last_pos[pos_index] - origin, 2, Color(1, 0, 0, pos_index*1.0/point_count))

	draw_target(viewport, current_position, Color.red)
	# Debug directions:
	#draw_line(current_position - viewport.position, current_position - viewport.position + Vector2.RIGHT.rotated(scene.world.map.ship_direction) * 100, Color.green)
	#draw_line(current_position - viewport.position, current_position - viewport.position + Vector2.RIGHT.rotated(scene.world.map.current_ship_direction) * 100, Color.yellow)
	
	var current_target = scene.world.map.current_ship_target
	if current_target != null:
		var current_target_adj = current_target * 100
		draw_target(viewport, current_target_adj, Color.green)
		draw_line(current_position - origin, current_target_adj - origin, Color.darkcyan)

func draw_target(viewport: Rect2, position: Vector2, color: Color):
	# Check if target is in range
	if viewport.has_point(position):
		draw_circle(position - viewport.position, 5, color)
	else:
		# Draw line pointing to target
		var relative_pos = position - viewport.position
		var clamped = Vector2(clamp(relative_pos.x, 0, viewport.size.x), clamp(relative_pos.y, 0, viewport.size.y))
		if relative_pos.x < 0:
			draw_line(Vector2(0, clamped.y-BORDER_LENGTH/2), Vector2(0, clamped.y+BORDER_LENGTH/2), color, BORDER_WIDTH)
		elif relative_pos.x > viewport.size.x:
			draw_line(Vector2(viewport.size.x, clamped.y-BORDER_LENGTH/2), Vector2(viewport.size.x, clamped.y+BORDER_LENGTH/2), color, BORDER_WIDTH)
		if relative_pos.y < 0:
			draw_line(Vector2(clamped.x-BORDER_LENGTH/2, 0), Vector2(clamped.x+BORDER_LENGTH/2, 0), color, BORDER_WIDTH)
		elif relative_pos.y > viewport.size.y:
			draw_line(Vector2(clamped.x-BORDER_LENGTH/2, viewport.size.y), Vector2(clamped.x+BORDER_LENGTH/2, viewport.size.y), color, BORDER_WIDTH)

func _input(event):
	if event is InputEventMouseButton:
		dragging = event.pressed
		last_origin = origin
		last_mouse_pos = event.position
		update()
	elif event is InputEventMouseMotion:
		if dragging:
			origin = last_origin - (event.position - last_mouse_pos)
			update()

func _reset_position():
	set_position = true