path: root/client/game.gd

# Hurry Curry! - a game about cooking
# Copyright 2024 nokoe
# Copyright 2024 metamuffin
# Copyright 2024 tpart
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, version 3 of the License only.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
#
class_name Game
extends Node3D

signal update_players(players: Dictionary)
signal data_updated()
signal in_lobby_updated(in_lobby: bool)
signal text_message(player: int, text: String, timeout_initial: float, timeout_remaining: float)
signal joined()
signal left()
signal update_tutorial_running(running: bool)

enum SpectatingMode {
	CENTER,
	FREE,
}

var player_id: int = -1
var item_names: Array = []
var item_index_by_name: Dictionary = {}
var tile_names: Array = []
var tile_index_by_name: Dictionary = {}
var tile_collide: Array = []
var tile_interact: Array = []
var maps: Array = []
var bot_algos: Array
var text_message_history: Array[Array] = []

var in_lobby := false
var is_replay := false
var is_joined := false
var join_sent := false
var tutorial_running := false
var tutorial_queue := []
var last_position := Vector2(0, 0)

var players := {}

var spectating_mode: SpectatingMode = SpectatingMode.CENTER

@onready var camera: FollowCamera = $FollowCamera
@onready var mp: Multiplayer = $Multiplayer
@onready var map: Map = $Map
@onready var lobby: Lobby = $"../Lobby"
@onready var overlay: Overlay = $"../Overlay"
@onready var popup_message: PopupMessage = $"../PopupMessage"
@onready var pinned_items: PinnedItemMessages = $"../PinnedItemMessages"
@onready var menu: GameMenu = $".."
@onready var follow_camera: FollowCamera = $FollowCamera

func _ready():
	mp.packet.connect(handle_packet)
	mp.connection_closed.connect(func(reason: String):
		Global.error_message = reason;
		get_parent().replace_menu("res://menu/error.tscn")
	)


func handle_packet(p):
	match p.type:
		"joined": player_id = p.id
		"data":
			item_names = p["data"]["item_names"]
			tile_names = p["data"]["tile_names"]
			tile_collide = p["data"]["tile_collide"]
			tile_interact = p["data"]["tile_interact"]
			maps = p["data"]["maps"]
			bot_algos = p["data"]["bot_algos"]

			tile_index_by_name.clear()
			for id in tile_names.size():
				tile_index_by_name[tile_names[id]] = id

			item_index_by_name.clear()
			for i in range(item_names.size()):
				item_index_by_name[item_names[i]] = i

			data_updated.emit()
		"add_player":
			var player_instance: Player
			if p.id == player_id:
				player_instance = ControllablePlayer.new(p.id, p.name, p.position, p.character, self)
				in_lobby_updated.connect(player_instance.onscreen_controls.in_lobby_updated)
				player_instance.onscreen_controls.in_lobby_updated(in_lobby)
				camera.target = player_instance.movement_base
				is_joined = true
				joined.emit()
			else:
				player_instance = Player.new(p.id, p.name, p.position, p.character, self)
			players[p.id] = player_instance
			add_child(player_instance)
			update_players.emit(players)
		"remove_player":
			var player: Player = players.get(p.id)
			if player == null:
				return
			if player.is_customer and player.current_item_message != null:
				tutorial_queue.erase(player.current_item_message)
			pinned_items.clear_item(p.id)
			if p.id == player_id:
				is_joined = false
				left.emit()
				camera.target = $Center
			if player.hand != null:
				player.hand.queue_free()
			players.erase(p.id)
			player.queue_free()
			update_players.emit(players)
		"movement":
			var player_instance: Player = players[p.player]
			player_instance.update_position(p.pos, p.rot, p.boost)
			if p.player == player_id: last_position = p.pos
		"movement_sync":
			if not players.has(player_id): return
			var player_instance: ControllablePlayer = players[player_id]
			player_instance.position_ = last_position
		"move_item":
			if "player" in p.from and "player" in p.to:
				players[p.from.player].pass_to(players[p.to.player])
			elif "tile" in p.from and "player" in p.to:
				var t: Tile = map.get_tile_instance(p.from.tile)
				players[p.to.player].take_item(t)
			elif "player" in p.from and "tile" in p.to:
				var t: Tile = map.get_tile_instance(p.to.tile)
				players[p.from.player].put_item(t)
			elif "tile" in p.from and "tile" in p.to:
				var from_tile2: Tile = map.get_tile_instance(p.from.tile)
				var to_tile2: Tile = map.get_tile_instance(p.to.tile)
				from_tile2.pass_to(to_tile2)
		"set_progress":
			if "tile" in p.item:
				var t: Tile = map.get_tile_instance(p.item.tile)
				t.progress(p.position, p.speed, p.warn, players.get(p.player))
			else:
				players[p.item.player].progress(p.position, p.speed, p.warn)
		"clear_progress":
			if "tile" in p.item:
				var t: Tile = map.get_tile_instance(p.item.tile)
				t.finish()
			else:
				players[p.item.player].finish()
		"set_item":
			var location: Dictionary = p["location"]
			if p.item != null:
				if "tile" in p.location:
					var t: Tile = map.get_tile_instance(p.location.tile)
					var i = ItemFactory.produce(item_names[p.item], t.item_base)
					i.position = t.item_base.global_position
					add_child(i)
					i.name = item_names[p.item]
					t.set_item(i)
				else:
					var pl: Player = players[p.location.player]
					var i = ItemFactory.produce(item_names[p.item], pl.hand_base)
					i.position = pl.hand_base.global_position
					add_child(i)
					i.name = item_names[p.item]
					pl.set_item(i)
			else:
				if "tile" in p.location:
					var t: Tile = map.get_tile_instance(p.location.tile)
					t.finish()
					t.set_item(null)
				else:
					var player: Player = players[p.location.player]
					player.finish()
					player.set_item(null)
		"update_map":
			var neighbors: Array = p["neighbors"]
			if p.kind != null:
				if neighbors != null: neighbors = neighbors.map(func(x): return tile_names[x] if x != null else null)
				map.set_tile(p.tile, tile_names[p.kind], neighbors)
			else: map.clear_tile(p.tile)
		"flush_map":
			map.flush()
		"communicate":
			var timeout_initial: float = p.timeout.initial if p.timeout != null else 5.
			var timeout_remaining: float = p.timeout.remaining if p.timeout != null else 5.
			var pinned: bool = p.timeout.pinned if p.timeout != null and "pinned" in p.timeout else false
			if p.message != null:
				if "item" in p.message:
					var item_name: String = item_names[p.message.item]
					var parsed_item := Global.ParsedItem.new(item_name)
					var ingredients := [parsed_item.name]
					ingredients.append_array(parsed_item.contents)
					
					if pinned:
						pinned_items.pin_item(item_name, timeout_initial, timeout_remaining, p.player)
					
					var player: Player = players[p.player]
					player.item_message(item_name, timeout_initial, timeout_remaining)
					
					# Maybe start tutorial
					if player.is_customer and not Global.get_setting("gameplay.tutorial_disabled"):
						var completed_ingredients: Array = Global.get_profile("tutorial_ingredients_played")
						var completed := Global.array_has_all(completed_ingredients, ingredients)
						
						if not completed:
							if tutorial_running:
								tutorial_queue.push_back(item_name)
							else:
								tutorial_running = true
								update_tutorial_running.emit(tutorial_running)
								mp.send_chat(player_id, "/start-tutorial %s" % item_name)
				elif "text" in p.message:
					if pinned:
						push_error("Pinned text messages are currently not supported")
					players[p.player].text_message(p.message.text, timeout_initial, timeout_remaining)
					var username: String = players[p.player].username
					text_message.emit(username, p.message.text, timeout_initial, timeout_remaining)
					text_message_history.append([username, p.message.text])
				else:
					push_error("neither text, item nor effect provided")
			else:
				var player: Player = players[p.player]
				if player.is_customer and player.current_item_message != null:
					tutorial_queue.erase(player.current_item_message)
				player.clear_message()
				pinned_items.clear_item(p.player)
		"effect":
			players[p.player].effect_message(p.name)
		"set_ingame":
			in_lobby = p.lobby
			overlay.set_ingame(p.state, p.lobby)
			follow_camera.set_ingame(p.state, p.lobby)
			
			if p.state:
				map.gi_bake()
				await get_parent()._menu_open()
				map.autobake = true

				if in_lobby: popup_message.lobby()
				else: popup_message.ingame()
			else:
				map.autobake = false
				await get_parent()._menu_exit()

			lobby.visible = in_lobby
			if lobby and not join_sent:
				join()

			in_lobby_updated.emit(in_lobby)
		"score":
			if p.time_remaining != null:
				overlay.update(p.demands_failed, p.demands_completed, p.points, p.time_remaining)
		"tutorial_ended":
			if p.player != player_id: return
			
			tutorial_running = false
			update_tutorial_running.emit(tutorial_running)
			
			if p.success:
				var completed_item := Global.ParsedItem.new(item_names[p.item])
				var played: Array = Global.get_profile("tutorial_ingredients_played")
				played.append(completed_item.name)
				played.append_array(completed_item.contents)
				Global.set_profile("tutorial_ingredients_played", played)
				Global.save_profile()
				
				while item_names[p.item] in tutorial_queue:
					tutorial_queue.erase(item_names[p.item])
			
				if not tutorial_queue.is_empty() and not Global.get_setting("gameplay.tutorial_disabled"):
					tutorial_running = true
					update_tutorial_running.emit(tutorial_running)
					mp.send_chat(player_id, "/start-tutorial %s" % tutorial_queue.pop_front())
			else:
				tutorial_queue.clear()
		"menu":
			match p.menu:
				"book":
					menu.submenu("res://menu/book/book.tscn")
				"score":
					menu.submenu("res://menu/rating/rating.tscn", [p.data.stars, p.data.points])
		"server_message":
			var mstr := get_message_str(p.message)
			if p.error:
				# popup_message.display_server_msg(tr("c.error.server").format([mstr]))
				push_error(tr("c.error.server").format([mstr]))
			else:
				popup_message.display_server_msg(mstr)
		"server_hint":
			if p.player != player_id: return
			
			var message = p.get("message")
			var position_ = p.get("position")
			
			if position_ == null:
				# Global hint message
				if message == null:
					popup_message.clear_server_msg()
				else:
					popup_message.display_server_msg(get_message_str(message), false)
			else:
				# Positional hint message
				if message == null:
					popup_message.clear_server_msg()
				else:
					popup_message.display_server_msg_positional(get_message_str(message), position_, false)
		"environment":
			$Environment.update(p.effects)
		"redirect":
			Global.server_url = p.uri[0]
			get_parent().replace_menu("res://menu/game.tscn")
		"replay_start":
			is_replay = true

		_: push_error("Unrecognized packet type: %s" % p.type)

func join():
	if join_sent:
		push_error("Join was already sent. Tried to join twice.")
		return
	join_sent = true
	mp.send_join(Global.get_profile("username"), Global.get_profile("character"))

func leave():
	join_sent = false
	mp.send_leave(player_id)

func _process(delta):
	update_center()

	if is_replay and mp != null:
		mp.send_replay_tick(delta)

func get_message_str(m: Dictionary) -> String:
	if "text" in m: return m.text
	if "translation" in m: return tr(m.translation.id).format(m.translation.params.map(get_message_str))
	if "tile" in m: return tile_names[m.tile]
	if "item" in m: return item_names[m.item]
	return "[unknown message type]"

func get_tile_collision(pos: Vector2i) -> bool:
	var t = map.get_tile_name(pos)
	if t == null: return true
	else: return tile_collide[tile_index_by_name[t]]

func get_tile_interactive(pos: Vector2i) -> bool:
	var t = map.get_tile_name(pos)
	if t == null: return false
	else: return tile_interact[tile_index_by_name[t]]


func update_center():
	if is_joined:
		return
	if Input.get_vector("left", "right", "forwards", "backwards").normalized().length() > .1:
		spectating_mode = SpectatingMode.FREE
	elif spectating_mode == SpectatingMode.FREE and Input.is_action_just_pressed("reset"):
		spectating_mode = SpectatingMode.CENTER
	match spectating_mode:
		SpectatingMode.CENTER:
			spectate_center()
		SpectatingMode.FREE:
			spectate_free()

func spectate_center():
	var sum: int = 0
	var player_sum: int = 0
	var center: Vector3 = Vector3(0.,0.,0.)
	var player_center: Vector3 = Vector3(0.,0.,0.)
	for v in players.values():
		var p: Player = v
		if p.character_idx >= 0:
			player_sum += 1
			player_center += p.movement_base.position
		sum += 1
		center += p.movement_base.position

	var new_center: Vector3 = Vector3(0.,0.,0.)
	if player_sum > 0:
		new_center = player_center / player_sum
	elif sum > 0:
		new_center = center / sum
	else:
		var extents = map.extents()
		var map_center = ((extents[0] + extents[1]) / 2) + Vector2(.5, .5)
		new_center = Vector3(map_center.x, 0.,map_center.y)
	$Center.position = new_center

func spectate_free():
	var direction := Input.get_vector("left", "right", "forwards", "backwards")
	direction = direction.rotated(-camera.angle_target)
	$Center.position += Vector3(
		direction.x,
		$Center.position.y,
		direction.y
	) * get_process_delta_time() * 10.
	var extents = map.extents()
	$Center.position.x = clamp($Center.position.x, extents[0].x, extents[1].x)
	$Center.position.z = clamp($Center.position.z, extents[0].y, extents[1].y)