ld53/Game.gd

extends Node2D

signal dropoff_score_changed
signal game_ended
# Declare member variables here. Examples:
# var a = 2
# var b = "text"

const Dropoff = preload("DropOff.tscn")
const Pickup = preload("Pickup.tscn")
const Start = preload("Start.tscn")
const Empty = preload("Empty.tscn")
const Link = preload("Link.tscn")
const Character = preload("Character.tscn")

# Configuration parameters
const default_params = {
	'seed': 'ld53',
	'node_count': 12,
	'cargo_availability': 2.0,
	'pickup_count_range': Vector2(1, 2),
	'empty_node_chance': 15,
	'dropoff_value_range': Vector2(1, 3),
	'dropoff_capacity_range': Vector2(1, 3),
	'link_cost_range': Vector2(1, 2),
}

static func easy_params():
	var p = default_params.duplicate()
	p.cargo_availability = INF;
	p.pickup_count_range = Vector2(1, 1)
	p.node_count = 6
	p.dropoff_capacity_range = Vector2(1, 2)
	p.link_cost_range = Vector2(1, 1)
	return p

static func medium_params():
	var p = default_params.duplicate()
	return p

static func hard_params():
	var p = default_params.duplicate()
	p.pickup_count_range = Vector2(1, 3)
	p.cargo_availability = 1.0
	p.node_count = 24
	p.dropoff_capacity_range = Vector2(1, 5)
	p.link_cost_range = Vector2(1, 3)
	return p

var params = null
var random = RandomNumberGenerator.new()

func get_levelcode():
	return Marshalls.variant_to_base64(self.params)

static func parse_levelcode(code):
	var p = Marshalls.base64_to_variant(code)
	# Make sure we have the keys present in the default params
	# Extraneous keys are ignored
	if p != null and !p.has_all(default_params.keys()):
		return null
	return p

func restart(new_params = null):
	if new_params:
		self.params = new_params
	for n in self.get_children():
		n.free()
	self._init(self.params['seed'])
	self.params = new_params
	self._ready()

func _init(random_seed: String = "ld53"):
	self.random = RandomNumberGenerator.new()
	print("Seed: %s" % random_seed)
	self.random.set_seed(hash(random_seed))

func random_position():
	var bottom = self.random.randi_range(0, 1)
	var right = self.random.randi_range(0, 1)
	var x_range = Vector2(
		32 + (right * 512),
		1024 + ((right - 1) * 512)
	)
	var y_range = Vector2(
		32 + (bottom * 300),
		600 + ((bottom - 1) * 300)
	)
	return Vector2(
		self.random.randi_range(x_range.x, x_range.y),
		self.random.randi_range(y_range.x, y_range.y)
	)

func indexed_position(index):
	# Positions are on a grid
	var row_count = 3
	var col_count = 4
	if self.params.node_count == 24:
		col_count = 6
		row_count = 4
	if self.params.node_count == 36:
		col_count = 6
		row_count = 6
	var row = index % row_count
	var col = index / row_count
	var position = Vector2(
		(1024 / col_count) * col,
		(600 / row_count) * row
	)
	var jitter_value = 64
	var jitter = Vector2(
		self.random.randi_range(-jitter_value, jitter_value),
		self.random.randi_range(-jitter_value, jitter_value)
	)
	return position + Vector2(64, 64) + jitter

func distance_to_closest_node(position, node):
	var closest = 65000
	for n in get_tree().get_nodes_in_group("nodes"):
		if n == node:
			continue
		var distance = n.get_position().distance_to(position)
		if distance < closest:
			closest = distance
	return closest

func link_nodes(n1, n2):
	assert(n1 != null)
	assert(n2 != null)
	var n = Link.instance()
	n.set_ends(n1, n2)
	n1.peers.append(n2)
	n2.peers.append(n1)
	n1.remove_from_group("unlinked")
	n2.remove_from_group("unlinked")
	add_child(n)
	# print("Linked ", n1, " to ", n2)
	# print("\tN1 peers: ", n1.peers)
	# print("\tN2 peers: ", n2.peers)
	return n

func reconstruct_path(cameFrom, current):
	var total_path = []
	while cameFrom.has(current):
		current = cameFrom[current]
		total_path.push_front(current)
	return total_path

func find_path(start, destination):
	var openSet = [start]
	var from = {}
	var gScore = {}
	var fScore = {}
	fScore[start] = 1
	while openSet.size() > 0:
		print(openSet)
		var current = null
		for n in openSet:
			if !fScore.has(n):
				fScore[n] = INF
			if current == null:
				current = n
			else:
				if fScore[n] < fScore[current]:
					current = n
		if current == destination:
			return reconstruct_path(from, current)
		openSet.remove(openSet.find(current))
		
		for n in current.peers:
			if !gScore.has(current):
				gScore[current] = INF
			var tentative_score = gScore[current] + 1
			if gScore.has(n) && tentative_score < gScore[n]:
				from[n] = current
				fScore[n] = tentative_score + 100
				gScore[n] = tentative_score
			if openSet.find(n) == -1:
				openSet.append(n)
	return null

func get_reachable_nodes(start):
	var nodes_in_starting_graph = [start] + start.peers
	var nodes_to_check = start.peers
	var nodes_checked = [start]
	while nodes_to_check.size() > 0:
		var checking_node = nodes_to_check.pop_front()
		#print("Checking: ", checking_node)
		#print("\tPeers", checking_node.peers)
		if nodes_checked.find(checking_node) != -1:
			continue
		for nx in checking_node.peers:
			if nodes_checked.find(nx) == -1:
				nodes_to_check.append(nx)
		if nodes_in_starting_graph.find(checking_node) == -1:
			nodes_in_starting_graph.append(checking_node)
		nodes_checked.append(checking_node)
	return nodes_in_starting_graph

# Called when the node enters the scene tree for the first time.
func _ready():
	if self.params == null:
		print("Resetting params")
		self.params = easy_params()
	var nodes = 0
	var n = null
	# Add start
	n = Start.instance()
	n.set_position(Vector2(512 - 32, 300-32))
	n.add_to_group("unlinked")
	n.name_from_index(nodes)
	self.add_child(n)
	var start = n
	nodes += 1
	
	# Add pickup(s)
	var count = self.random.randi_range(self.params.pickup_count_range.x, self.params.pickup_count_range.y)
	while count > 0:
		n = Pickup.instance()
		n.add_to_group("unlinked")
		n.name_from_index(nodes)
		self.add_child(n)
		count -= 1
		nodes += 1
	
	# Add other node(s)
	var total_to_dropoff = 0
	while nodes < self.params.node_count + 1:
		if self.random.randi_range(0, 99) < self.params.empty_node_chance:
			n = Empty.instance()
		else:
			n = Dropoff.instance()
			n.capacity = self.random.randi_range(self.params.dropoff_capacity_range.x, self.params.dropoff_capacity_range.y)
			n.value = self.random.randi_range(self.params.dropoff_value_range.x, self.params.dropoff_value_range.y)
			total_to_dropoff += n.capacity
		n.add_to_group("unlinked")
		n.name_from_index(nodes)
		self.add_child(n)
		print("Added node: ", n)
		nodes += 1
	
	# Distribute available cargo between dropoff points randomly when finite
	# amount available.
	if !is_inf(self.params.cargo_availability):
		var cargo_available = total_to_dropoff * self.params.cargo_availability
		for cargo_node in get_tree().get_nodes_in_group("pickup"):
			var cargo_count = self.random.randi_range(1, cargo_available)
			cargo_available -= cargo_count
			cargo_node.set_stored(cargo_count)
		if cargo_available > 0:
			get_tree().get_nodes_in_group("pickup")[-1].add_stored(cargo_available)

	# Each node should have at least one link
	var unlinked_nodes = get_tree().get_nodes_in_group("unlinked")
	while unlinked_nodes.size() > 0:
		var source = unlinked_nodes.pop_front()
		var targets = get_tree().get_nodes_in_group("nodes")
		var target = targets[self.random.randi_range(0, targets.size()-1)]
		while target == source:
			target = targets[self.random.randi_range(0, targets.size()-1)]
		var link = link_nodes(source, target)
		link.set_weight(self.random.randi_range(
			self.params.link_cost_range.x,
			self.params.link_cost_range.y
		))
		
		unlinked_nodes = get_tree().get_nodes_in_group("unlinked")
	
	# For each node, make sure we can reach the start node, merging
	# any disjointed graphs
	var nodes_in_starting_graph = get_reachable_nodes(start)
	
	print("Starting graph nodes: ", nodes_in_starting_graph)
	for node in get_tree().get_nodes_in_group("nodes"):
		if nodes_in_starting_graph.find(node) == -1:
			print(node, " can't be reached from start")
			var target = nodes_in_starting_graph[self.random.randi_range(0, nodes_in_starting_graph.size()-1)]
			link_nodes(node, target)
			nodes_in_starting_graph = get_reachable_nodes(start)
			
	# Set new node positions
	# @TODO: Better (?) layout algorithm, eg. https://en.wikipedia.org/wiki/Graph_drawing
	var x_range = Vector2(32, 1024-32)
	var y_range = Vector2(32, 600-32)
	var distance_threshold = 32
	var idx = 0
	for node in get_tree().get_nodes_in_group("nodes"):
		if node.is_in_group("start"):
			continue
		var position = self.indexed_position(idx)
		var tries = 0
		var closest = distance_to_closest_node(position, node)
		# While the position is within a distance of another node, rechoose
		while closest <= distance_threshold:
			if closest == 0:
				closest = 65000	
			for n2 in get_tree().get_nodes_in_group("nodes"):
				if n2 == node:
					continue
				var distance = n2.get_position().distance_to(position)
				if distance < closest:
					closest = distance
			# print("Closest point to ", position, " ", closest)
			tries += 1
			if tries % 10 == 0:
				distance_threshold /= 2
				print("Reducing threshold for point ", node, " to ", distance_threshold)
			position = self.random_position()
		node.set_position(position)
		# print("Placed node ", node, " after ", tries, " tries")
		idx += 1
		
		

	# Update link linepositions based on the node positions
	for link in get_tree().get_nodes_in_group("links"):
		link.redraw_line()
		# @BUG It shouldn't be necessary to recalculate the peers
		# For some reason, we lose the peer on the start node
		if link.start == start:
			start.peers.append(link.end)
		if link.end == start:
			start.peers.append(link.start)
	
	# Add player
	n = Character.instance()
	add_child(n)
	n.add_to_group("character")
	n.set_location(start, true)
	n.connect("arrived_at", self, "on_character_arrival")


func on_character_arrival(node):
	if node.is_in_group("dropoff"):
		var max_delivery = node.capacity - node.stored
		var max_avail = get_node("Character").stored
		var delta = min(max_avail, max_delivery)
		print("Dropoff %d to %s" % [delta, node])
		get_node("Character").dropoff(delta)
		node.receive(delta)
		# Recalculate dropoff score
		var score = self.get_supplied()
		var all_supplied = score[0] >= score[1]
		emit_signal("dropoff_score_changed", [score[2], score[3]])
		if all_supplied:
			emit_signal("game_ended")
	elif node.is_in_group("pickup"):
		var max_pickup = get_node("Character").capacity - get_node("Character").stored
		var min_avail = node.stored
		var delta = min(min_avail, max_pickup)
		print("Pickup up %d from %s" % [delta, node])
		get_node("Character").pickup(delta)
		node.drain(delta)
	elif node.is_in_group("start"):
		print("@TODO: Start")
		
func get_moves():
	return get_node("Character").movement_cost
	
func get_score():
	var data = get_supplied()
	# Delivered + Supplied bonus - Movement
	return data[2] + data[3] - get_moves()
	
func get_supplied():
	# [nodes_done, nodes_total, earned_value, cargo_done, cargo_total]
	var done = 0
	var dropoff_score = 0
	var cargo_done = 0
	var cargo_total = 0
	for n in get_tree().get_nodes_in_group("dropoff"):
		cargo_total += n.capacity
		cargo_done += n.stored
		if n.stored >= n.capacity:
			dropoff_score += n.value
			done += 1
	return [
		done,
		get_tree().get_nodes_in_group("dropoff").size(),
		dropoff_score,
		cargo_done,
		cargo_total
	]

# Called every frame. 'delta' is the elapsed time since the previous frame.
#func _process(delta):
#	pass