ComfyFactorio/maps/pirates/crew.lua

-- This file is part of thesixthroc's Pirate Ship softmod, licensed under GPLv3 and stored at https://github.com/danielmartin0/ComfyFactorio-Pirates.


local Balance = require 'maps.pirates.balance'
local _inspect = require 'utils.inspect'.inspect
local Memory = require 'maps.pirates.memory'
local Math = require 'maps.pirates.math'
local Common = require 'maps.pirates.common'
-- local Parrot = require 'maps.pirates.parrot'
local CoreData = require 'maps.pirates.coredata'
local Server = require 'utils.server'
local Utils = require 'maps.pirates.utils_local'
local Surfaces = require 'maps.pirates.surfaces.surfaces'
-- local Structures = require 'maps.pirates.structures.structures'
local Boats = require 'maps.pirates.structures.boats.boats'
local Crowsnest = require 'maps.pirates.surfaces.crowsnest'
local Hold = require 'maps.pirates.surfaces.hold'
local Lobby = require 'maps.pirates.surfaces.lobby'
local Cabin = require 'maps.pirates.surfaces.cabin'
local Roles = require 'maps.pirates.roles.roles'
local Classes = require 'maps.pirates.roles.classes'
local Token = require 'utils.token'
local Task = require 'utils.task'
local SurfacesCommon = require 'maps.pirates.surfaces.common'

local Public = {}
local enum = {
		ADVENTURING = 'adventuring',
		LEAVING_INITIAL_DOCK = 'leavinginitialdock'
}
Public.enum = enum


function Public.difficulty_vote(player_index, difficulty_id)
	local memory = Memory.get_crew_memory()


	if not (memory.difficulty_votes) then memory.difficulty_votes = {} end
	local player = game.players[player_index]
	if not (player and player.valid) then return end


	if memory.difficulty_votes[player_index] and memory.difficulty_votes[player_index] == difficulty_id then
		return nil
	else
		log(_inspect(CoreData.difficulty_options))
		local option = CoreData.difficulty_options[difficulty_id]
		if not option then return end

		local color = option.associated_color
		Common.notify_force(memory.force, {'pirates.notify_difficulty_vote',player.name, color.r, color.g, color.b, option.text})

		memory.difficulty_votes[player_index] = difficulty_id

		Public.update_difficulty()
	end
end


function Public.update_difficulty()
	local memory = Memory.get_crew_memory()

	local vote_counts = {}
	for _, difficulty_id in pairs(memory.difficulty_votes) do
		if not vote_counts[difficulty_id] then
			vote_counts[difficulty_id] = 1
		else
			vote_counts[difficulty_id] = vote_counts[difficulty_id] + 1
		end
	end

	local modal_id = 1
	local modal_count = 0
	for difficulty_id, votes in pairs(vote_counts) do
		if votes > modal_count or (votes == modal_count and difficulty_id < modal_id) then
			modal_count = votes
			modal_id = difficulty_id
		end
	end

	if modal_id ~= memory.difficulty_option then
		local color = CoreData.difficulty_options[modal_id].associated_color

		local message1 = {'pirates.notify_difficulty_change', color.r, color.g, color.b, CoreData.difficulty_options[modal_id].text}

		Common.notify_force(memory.force, message1)

		-- local message2 = 'Difficulty changed to ' .. CoreData.difficulty_options[modal_id].text .. '.'
		Server.to_discord_embed_raw({'', CoreData.comfy_emojis.kewl .. '[' .. memory.name .. '] ', message1}, true)

		memory.difficulty_option = modal_id
		memory.difficulty = CoreData.difficulty_options[modal_id].value
	end
end


function Public.try_add_extra_time_at_sea(ticks)
	local memory = Memory.get_crew_memory()

	if not memory.extra_time_at_sea then memory.extra_time_at_sea = 0 end

	if memory.extra_time_at_sea >= CoreData.max_extra_seconds_at_sea * 60 then return false end

	-- if memory.boat and memory.boat.state and memory.boat.state == Boats.enum_state.ATSEA_LOADING_MAP then return false end

	memory.extra_time_at_sea = memory.extra_time_at_sea + ticks
	return true
end

function Public.get_crewmembers_printable_string()
	local crewmembers_string = ''
	for _, player in pairs(Common.crew_get_crew_members()) do
		if player.valid then
			if crewmembers_string ~= '' then crewmembers_string = crewmembers_string .. ', ' end
			crewmembers_string = crewmembers_string .. player.name
		end
	end
	if crewmembers_string ~= '' then crewmembers_string = crewmembers_string .. '.' end

	return crewmembers_string
end

function Public.try_lose(loss_reason)
	local memory = Memory.get_crew_memory()

	if (not memory.game_lost) then
	-- if (not memory.game_lost) and (not memory.game_won) then
		memory.game_lost = true
		memory.crew_disband_tick = game.tick + 360

		local playtimetext = Utils.time_longform((memory.age or 0)/60)

		local message = {'',loss_reason,' ',{'pirates.loss_rest_of_message_long', playtimetext, Public.get_crewmembers_printable_string()}}

		Server.to_discord_embed_raw({'',CoreData.comfy_emojis.trashbin .. '[' .. memory.name .. '] ', message}, true)

		local message2 = {'',loss_reason,' ',{'pirates.loss_rest_of_message_short', '[font=default-large-semibold]' .. playtimetext .. '[/font]'}}

		Common.notify_game({'', '[' .. memory.name .. '] ',message2}, CoreData.colors.notify_gameover)

		local force = memory.force
		if not (force and force.valid) then return end

		force.play_sound{path='utility/game_lost', volume_modifier=0.75} --playing to the whole game might scare ppl
	end
end

function Public.try_win()
	local memory = Memory.get_crew_memory()

	if (not (memory.game_lost or memory.game_won)) then
	-- if (not memory.game_lost) and (not memory.game_won) then
		memory.completion_time = Math.floor((memory.age or 0)/60)

		local speedrun_time = (memory.age or 0)/60
		local speedrun_time_str = Utils.time_longform(speedrun_time)
		memory.game_won = true
		-- memory.crew_disband_tick = game.tick + 1200

		Server.to_discord_embed_raw({'', CoreData.comfy_emojis.goldenobese .. '[' .. memory.name .. '] Victory, on v' .. CoreData.version_string .. ', ', CoreData.difficulty_options[memory.difficulty_option].text, ', capacity ' .. CoreData.capacity_options[memory.capacity_option].text3 .. '. Playtime: ' .. speedrun_time_str .. ' since 1st island. Crewmembers: ' .. Public.get_crewmembers_printable_string()}, true)

		Common.notify_game({'','[' .. memory.name .. '] ',{'pirates.victory',CoreData.version_string, CoreData.difficulty_options[memory.difficulty_option].text, CoreData.capacity_options[memory.capacity_option].text3, speedrun_time_str, Public.get_crewmembers_printable_string()}}, CoreData.colors.notify_victory)

		game.play_sound{path='utility/game_won', volume_modifier=0.9}

		memory.victory_pause_until_tick = game.tick + 60*18
		memory.victory_continue_message = true
	end
end


function Public.choose_crew_members()
	-- local global_memory = Memory.get_global_memory()
	local memory = Memory.get_crew_memory()
	local capacity = memory.capacity
	local boat = memory.boat

	-- if the boat is over capacity, should prefer original endorsers over everyone else:
	local crew_members = {}
	local crew_members_count = 0
	for _, player in pairs(game.connected_players) do
		if crew_members_count < capacity and player.surface.name == CoreData.lobby_surface_name and Boats.on_boat(boat, player.position) then
			-- check if they were an endorser
			local endorser = false
			for _, index in pairs(memory.original_proposal.endorserindices) do
				if player.index == index then endorser = true end
			end
			if endorser then
				crew_members[player.index] = player
				crew_members_count = crew_members_count + 1
			end
		end
	end

	if crew_members_count < capacity then
		for _, player in pairs(game.connected_players) do
			if crew_members_count < capacity and (not crew_members[player.index]) and player.surface.name == CoreData.lobby_surface_name and Boats.on_boat(boat, player.position) then
				crew_members[player.index] = player
				crew_members_count = crew_members_count + 1
			end
		end
	end

	for _, player in pairs(crew_members) do
		player.force = memory.force
		memory.crewplayerindices[#memory.crewplayerindices + 1] = player.index
	end

	return crew_members
end


function Public.join_spectators(player, crewid)
	if not (crewid > 0) then return end

	Memory.set_working_id(crewid)
	local memory = Memory.get_crew_memory()

	local force = memory.force
	if not (force and force.valid and Common.validate_player(player)) then return end

	local surface = game.surfaces[CoreData.lobby_surface_name]

	local adventuring = false
	local spectating = false
	if memory.crewstatus and memory.crewstatus == enum.ADVENTURING then
		for _, playerindex in pairs(memory.crewplayerindices) do
			if player.index == playerindex then adventuring = true end
		end
		for _, playerindex in pairs(memory.spectatorplayerindices) do
			if player.index == playerindex then spectating = true end
		end
	end

	if spectating then return end

	if adventuring then
		local char = player.character

		if char and char.valid then
			local p = char.position
			-- local surface_name = char.surface.name
			if p then
				Common.notify_force(force, {'pirates.crew_to_spectator', player.name})
				-- Server.to_discord_embed_raw(CoreData.comfy_emojis.feel .. '[' .. memory.name .. '] ' .. message)
			end
			-- if p then
			-- 	Common.notify_force(force, message .. ' to become a spectator.' .. ' [gps=' .. Math.ceil(p.x) .. ',' .. Math.ceil(p.y) .. ',' .. surface_name ..']')
			-- 	-- Server.to_discord_embed_raw(CoreData.comfy_emojis.feel .. '[' .. memory.name .. '] ' .. message)
			-- end

			Common.send_important_items_from_player_to_crew(player, true)
			char.die(memory.force_name)

			player.set_controller{type = defines.controllers.spectator}
		else
			Common.notify_force(force, {'pirates.crew_to_spectator', player.name})
			-- Server.to_discord_embed_raw(CoreData.comfy_emojis.feel .. '[' .. memory.name .. '] ' .. message)
			player.set_controller{type = defines.controllers.spectator}
		end

		local c = surface.create_entity{name = 'character', position = surface.find_non_colliding_position('character', Common.lobby_spawnpoint, 32, 0.5) or Common.lobby_spawnpoint, force = 'player'}

		player.associate_character(c)

		player.set_controller{type = defines.controllers.spectator}

		memory.crewplayerindices = Utils.ordered_table_with_values_removed(memory.crewplayerindices, player.index)

		Roles.player_left_so_redestribute_roles(player)
	else
		Public.player_abandon_endorsements(player)
		local c = player.character
		player.set_controller{type = defines.controllers.spectator}
		player.teleport(memory.spawnpoint, game.surfaces[Common.current_destination().surface_name])
		player.force = force
		player.associate_character(c)

		Common.notify_force(force, {'pirates.lobby_to_spectator', player.name})
		Common.notify_lobby({'pirates.lobby_to_spectator_2', player.name, memory.name})
	end
	memory.spectatorplayerindices[#memory.spectatorplayerindices + 1] = player.index
	memory.tempbanned_from_joining_data[player.index] = game.tick
	-- if #Common.crew_get_crew_members() == 0 then
	-- 	memory.crew_disband_tick = game.tick + 30
	-- 	-- memory.crew_disband_tick = game.tick + 60*60*2 --give players time to log back in after a crash or save
	-- end
	if not (memory.difficulty_votes) then memory.difficulty_votes = {} end
	memory.difficulty_votes[player.index] = nil
end


function Public.leave_spectators(player, quiet)
	quiet = quiet or false
	local memory = Memory.get_crew_memory()
	local surface = game.surfaces[CoreData.lobby_surface_name]

	if not Common.validate_player(player) then return end

	if not quiet then
		Common.notify_force(player.force, {'pirates.spectator_to_lobby', player.name})
	end

	local chars = player.get_associated_characters()
	if #chars > 0 then
		player.teleport(chars[1].position, surface)
		player.set_controller{type = defines.controllers.character, character = chars[1]}
	else
		player.set_controller{type = defines.controllers.god}
		player.teleport(surface.find_non_colliding_position('character', Common.lobby_spawnpoint, 32, 0.5) or Common.lobby_spawnpoint, surface)
		player.create_character()
	end

	memory.spectatorplayerindices = Utils.ordered_table_with_values_removed(memory.spectatorplayerindices, player.index)

	if #Common.crew_get_crew_members() == 0 then
		if Common.autodisband_ticks then
			memory.crew_disband_tick = game.tick + Common.autodisband_ticks
		end
		if _DEBUG then memory.crew_disband_tick = game.tick + 30*60*60 end
	end

	player.force = 'player'
end


function Public.join_crew(player, crewid, rejoin)
	if not crewid then return end

	Memory.set_working_id(crewid)
	local memory = Memory.get_crew_memory()

	if not Common.validate_player(player) then return end

	-- local startsurface = game.surfaces[CoreData.lobby_surface_name]

	local boat = memory.boat
	local surface
	if boat and boat.surface_name and game.surfaces[boat.surface_name] and game.surfaces[boat.surface_name].valid then
		surface = game.surfaces[boat.surface_name]
	else
		surface = game.surfaces[Common.current_destination().surface_name]
	end

	-- local adventuring = false
	local spectating = false
	if memory.crewstatus and memory.crewstatus == enum.ADVENTURING then
		-- for _, playerindex in pairs(memory.crewplayerindices) do
		-- 	if player.index == playerindex then adventuring = true end
		-- end
		for _, playerindex in pairs(memory.spectatorplayerindices) do
			if player.index == playerindex then spectating = true end
		end
	end

	if spectating then
		local chars = player.get_associated_characters()
		for _, char in pairs(chars) do
				char.destroy()
		end

		player.teleport(surface.find_non_colliding_position('character', memory.spawnpoint, 32, 0.5) or memory.spawnpoint, surface)

		player.set_controller{type = defines.controllers.god}
		player.create_character()

		memory.spectatorplayerindices = Utils.ordered_table_with_values_removed(memory.spectatorplayerindices, player.index)
	else
		Public.player_abandon_endorsements(player)
		player.force = memory.force
		player.teleport(surface.find_non_colliding_position('character', memory.spawnpoint, 32, 0.5) or memory.spawnpoint, surface)

	Common.notify_lobby({'pirates.lobby_to_crew_2', player.name, memory.name})
	end

	Common.notify_force(player.force, {'pirates.lobby_to_crew', player.name})
	-- Server.to_discord_embed_raw(CoreData.comfy_emojis.yum1 .. '[' .. memory.name .. '] ' .. message)

	memory.crewplayerindices[#memory.crewplayerindices + 1] = player.index

	-- don't give them items if they've been in the crew recently:
	if not (memory.tempbanned_from_joining_data and memory.tempbanned_from_joining_data[player.index]) and (not rejoin) then --just using tempbanned_from_joining_data as a quick proxy for whether the player has ever been in this run before
		for item, amount in pairs(Balance.starting_items_player_late) do
			player.insert({name = item, count = amount})
		end
	end

	Roles.confirm_captain_exists(player)

	if #Common.crew_get_crew_members() == 1 and memory.crew_disband_tick then
		memory.crew_disband_tick = nil --to prevent disbanding the crew after saving the game (booting everyone) and loading it again (joining the crew as the only member)
	end

	if memory.overworldx > 0 then
		local color = CoreData.difficulty_options[memory.difficulty_option].associated_color

		Common.notify_player_announce(player, {'pirates.personal_join_string_1', memory.name, CoreData.capacity_options[memory.capacity_option].text3, color.r, color.g, color.b, CoreData.difficulty_options[memory.difficulty_option].text})
	else
		Common.notify_player_announce(player, {'pirates.personal_join_string_1', memory.name, CoreData.capacity_options[memory.capacity_option].text3})
	end
end

function Public.leave_crew(player, to_lobby, quiet)
	quiet = quiet or false
	local memory = Memory.get_crew_memory()
	local surface = game.surfaces[CoreData.lobby_surface_name]

	if not Common.validate_player(player) then return end

	local char = player.character
	if char and char.valid then
		-- local p = char.position
		-- local surface_name = char.surface.name
		if not quiet then
			Common.notify_force(player.force, {'pirates.crew_leave', player.name})
		-- else
		-- 	message = player.name .. ' left.'
		end
		-- if p then
		-- 	Common.notify_force(player.force, message .. ' [gps=' .. Math.ceil(p.x) .. ',' .. Math.ceil(p.y) .. ',' .. surface_name ..']')
		-- 	-- Server.to_discord_embed_raw(CoreData.comfy_emojis.feel .. '[' .. memory.name .. '] ' .. message)
		-- end

		if to_lobby then
			Common.send_important_items_from_player_to_crew(player, true)
			char.die(memory.force_name)
		else
			Common.send_important_items_from_player_to_crew(player)
			memory.temporarily_logged_off_characters[player.index] = game.tick
		end
	-- else
	-- 	if not quiet then
	-- 		-- local message = player.name .. ' left the crew.'
	-- 		-- Common.notify_force(player.force, message)
	-- 	end
	end

	if to_lobby then
		player.set_controller{type = defines.controllers.god}

		player.teleport(surface.find_non_colliding_position('character', Common.lobby_spawnpoint, 32, 0.5) or Common.lobby_spawnpoint, surface)
		player.force = 'player'
		player.create_character()
	end

	memory.crewplayerindices = Utils.ordered_table_with_values_removed(memory.crewplayerindices, player.index)

	-- setting it to this won't ban them from rejoining, it just affects the loot they spawn in with:
	memory.tempbanned_from_joining_data[player.index] = game.tick - Common.ban_from_rejoining_crew_ticks

	if not (memory.difficulty_votes) then memory.difficulty_votes = {} end
	memory.difficulty_votes[player.index] = nil

	if #Common.crew_get_crew_members() == 0 then
		if Common.autodisband_ticks then
			memory.crew_disband_tick = game.tick + Common.autodisband_ticks
		end
		-- memory.crew_disband_tick = game.tick + 60*60*2 --give players time to log back in after a crash or save
		if _DEBUG then memory.crew_disband_tick = game.tick + 30*60*60 end
	else
		Roles.player_left_so_redestribute_roles(player)
	end
end



function Public.get_unaffiliated_players()
	local global_memory = Memory.get_global_memory()

	local playerlist = {}
	for _, player in pairs(game.connected_players) do
		local found = false
		for _, id in pairs(global_memory.crew_active_ids) do
			Memory.set_working_id(id)
			for _, player2 in pairs(Common.crew_get_crew_members_and_spectators()) do
				if player == player2 then found = true end
			end
		end
		if not found then playerlist[#playerlist + 1] = player end
	end
	return playerlist
end


function Public.plank(captain, player)
	local memory = Memory.get_crew_memory()

	if Utils.contains(Common.crew_get_crew_members(), player) then
		if (not (captain.index == player.index)) then
			Server.to_discord_embed_raw(CoreData.comfy_emojis.monkas .. string.format("%s planked %s!", captain.name, player.name))

			Common.notify_force(player.force, {'pirates.plank', captain.name, player.name})

			Public.join_spectators(player, memory.id)
			memory.tempbanned_from_joining_data[player.index] = game.tick + 60 * 120
			return true
		else
			Common.notify_player_error(player, {'pirates.plank_error_self'})
			return false
		end
	else
		Common.notify_player_error(player, {'pirates.plank_error_invalid_player'})
		return false
	end
end



function Public.disband_crew(donotprint)
	local global_memory = Memory.get_global_memory()
	local memory = Memory.get_crew_memory()

	if not memory.name then return end

	local id = memory.id
	local players = Common.crew_get_crew_members_and_spectators()

	for _,player in pairs(players) do
		if player.controller_type == defines.controllers.editor then player.toggle_map_editor() end
		player.force = 'player'
	end

	if (not donotprint) then

		local message = {'pirates.crew_disband', memory.name, Utils.time_longform((memory.real_age or 0)/60)}
		Common.notify_game(message)
		Server.to_discord_embed_raw({'', CoreData.comfy_emojis.monkas, message}, true)

		-- if memory.game_won then
		--		 game.print({'chronosphere.message_game_won_restart'}, {r=0.98, g=0.66, b=0.22})
		-- end
	end


	Public.reset_crew_and_enemy_force(id)

	local lobby = game.surfaces[CoreData.lobby_surface_name]
	for _, player in pairs(players) do

		if player.character then
			player.character.destroy()
			player.character = nil
		end

		player.set_controller({type=defines.controllers.god})

		if player.get_associated_characters() and #player.get_associated_characters() == 1 then
			local char = player.get_associated_characters()[1]
			player.teleport(char.position, char.surface)

			player.set_controller({type=defines.controllers.character, character=char})
		else
			local pos = lobby.find_non_colliding_position('character', Common.lobby_spawnpoint, 32, 0.5) or Common.lobby_spawnpoint
			player.teleport(pos, lobby)
			player.create_character()
		end
	end

	if memory.sea_name then
		local seasurface = game.surfaces[memory.sea_name]
		if seasurface then game.delete_surface(seasurface) end
	end

	for i = 1, memory.hold_surface_count do
		local holdname = Hold.get_hold_surface_name(i)
		if game.surfaces[holdname] then
			game.delete_surface(game.surfaces[holdname])
		end
	end

	local cabinname = Cabin.get_cabin_surface_name()
	if game.surfaces[cabinname] then
		game.delete_surface(game.surfaces[cabinname])
	end

	local s = Hold.get_hold_surface(1)
	if s and s.valid then
		log('hold failed to delete')
	end

	s = Cabin.get_cabin_surface()
	if s and s.valid then
		log(_inspect(cabinname))
		log('cabin failed to delete')
	end

	local crowsnestname = SurfacesCommon.encode_surface_name(memory.id, 0, Surfaces.enum.CROWSNEST, nil)
	if game.surfaces[crowsnestname] then game.delete_surface(game.surfaces[crowsnestname]) end

	for _, destination in pairs(memory.destinations) do
		if game.surfaces[destination.surface_name] then game.delete_surface(game.surfaces[destination.surface_name]) end
	end

	global_memory.crew_memories[id] = nil
	for k, idd in pairs(global_memory.crew_active_ids) do
		if idd == id then table.remove(global_memory.crew_active_ids, k) end
	end

	Lobby.place_starting_dock_showboat(id)
end


function Public.generate_new_crew_id()
	local global_memory = Memory.get_global_memory()

	if not global_memory.crew_memories[1] then return 1
	elseif not global_memory.crew_memories[2] then return 2
	elseif not global_memory.crew_memories[3] then return 3
	else return end
end


function Public.player_abandon_proposal(player)
	local global_memory = Memory.get_global_memory()

	for k, proposal in pairs(global_memory.crewproposals) do
		if proposal.endorserindices and proposal.endorserindices[1] and proposal.endorserindices[1] == player.index then
			proposal.endorserindices[k] = nil
			Common.notify_lobby({'pirates.proposal_retracted', proposal.name})
			-- Server.to_discord_embed(message)
			global_memory.crewproposals[k] = nil
		end
	end
end

function Public.player_abandon_endorsements(player)
	local global_memory = Memory.get_global_memory()

	for k, proposal in pairs(global_memory.crewproposals) do
		for k2, i in pairs(proposal.endorserindices) do
			if i == player.index then
				proposal.endorserindices[k2] = nil
				if #proposal.endorserindices == 0 then
					Common.notify_lobby({'pirates.proposal_abandoned', proposal.name})
					-- Server.to_discord_embed(message)
					global_memory.crewproposals[k] = nil
				end
			end
		end
	end
end


local crowsnest_delayed = Token.register(
	function(data)
		Memory.set_working_id(data.crew_id)
		Crowsnest.crowsnest_surface_delayed_init()
	end
)
function Public.initialise_crowsnest()
	local memory = Memory.get_crew_memory()
	Crowsnest.create_crowsnest_surface()
	Task.set_timeout_in_ticks(5, crowsnest_delayed, {crew_id = memory.id})
end

function Public.initialise_crowsnest_1()
	Crowsnest.create_crowsnest_surface()
end
function Public.initialise_crowsnest_2()
	Crowsnest.crowsnest_surface_delayed_init()
end

function Public.initialise_crew(accepted_proposal)
	local global_memory = Memory.get_global_memory()

	local new_id = Public.generate_new_crew_id()

	global_memory.crew_active_ids[#global_memory.crew_active_ids + 1] = new_id

	Memory.initialise_crew_memory(new_id)
	Memory.set_working_id(new_id)

	game.reset_time_played() -- affects the multiplayer lobby view

	local memory = Memory.get_crew_memory()

    local secs = Server.get_current_time()
	if not secs then secs = 0 end
	memory.secs_id = secs

	memory.id = new_id

	memory.force_name = Common.get_crew_force_name(new_id)
	memory.enemy_force_name = Common.get_enemy_force_name(new_id)
	memory.ancient_enemy_force_name = Common.get_ancient_hostile_force_name(new_id)
	memory.ancient_friendly_force_name = Common.get_ancient_friendly_force_name(new_id)

	memory.force = game.forces[memory.force_name]
	memory.enemy_force = game.forces[memory.enemy_force_name]
	memory.ancient_enemy_force = game.forces[memory.ancient_enemy_force_name]
	memory.ancient_friendly_force = game.forces[memory.ancient_friendly_force_name]

	memory.evolution_factor = 0

	memory.delayed_tasks = {}
	memory.buffered_tasks = {}
	memory.crewplayerindices = {}
	memory.spectatorplayerindices = {}
	memory.tempbanned_from_joining_data = {}
	memory.destinations = {}
	memory.temporarily_logged_off_characters = {}
	memory.class_renderings = {}
	memory.class_auxiliary_data = {}

	memory.hold_surface_count = 1

	memory.speed_boost_characters = {}

	memory.original_proposal = accepted_proposal
	memory.name = accepted_proposal.name
	memory.difficulty_option = accepted_proposal.difficulty_option
	memory.capacity_option = accepted_proposal.capacity_option
	-- memory.mode_option = accepted_proposal.mode_option
	memory.difficulty = CoreData.difficulty_options[accepted_proposal.difficulty_option].value
	memory.capacity = CoreData.capacity_options[accepted_proposal.capacity_option].value
	-- memory.mode = CoreData.mode_options[accepted_proposal.mode_option].value

	memory.destinationsvisited_indices = {}
	memory.stored_fuel = Balance.starting_fuel
	memory.available_classes_pool = Classes.initial_class_pool()
	memory.playtesting_stats = {
		coins_gained_by_biters = 0,
		coins_gained_by_nests_and_worms = 0,
		coins_gained_by_trees_and_rocks = 0,
		coins_gained_by_ore = 0,
		coins_gained_by_rocket_launches = 0,
		coins_gained_by_markets = 0,
		coins_gained_by_krakens = 0,
	}

	memory.captain_accrued_time_data = {}
	memory.max_players_recorded = 0

	memory.classes_table = {}
	memory.officers_table = {}
	memory.spare_classes = {}

	memory.healthbars = {}
	memory.overworld_krakens = {}
	memory.kraken_stream_registrations = {}

	memory.overworldx = 0
	memory.overworldy = 0

	memory.hold_surface_destroyable_wooden_chests = {}

	memory.seaname = SurfacesCommon.encode_surface_name(memory.id, 0, SurfacesCommon.enum.SEA, enum.DEFAULT)

	local surface = game.surfaces[CoreData.lobby_surface_name]
	memory.spawnpoint = Common.lobby_spawnpoint

	memory.force.set_spawn_position(memory.spawnpoint, surface)

	local message = {'pirates.crew_launch', accepted_proposal.name}
	Common.notify_game(message)
	-- Server.to_discord_embed_raw(CoreData.comfy_emojis.pogkot .. message .. ' Difficulty: ' .. CoreData.difficulty_options[memory.difficulty_option].text .. ', Capacity: ' .. CoreData.capacity_options[memory.capacity_option].text3 .. '.')
	Server.to_discord_embed_raw({'',CoreData.comfy_emojis.pogkot,message,' Capacity: ',CoreData.capacity_options[memory.capacity_option].text3,'.'}, true)
	game.surfaces[CoreData.lobby_surface_name].play_sound{path='utility/new_objective', volume_modifier=0.75}

	memory.boat = global_memory.lobby_boats[new_id]
	local boat = memory.boat

	for _, e in pairs(memory.boat.cannons_temporary_reference or {}) do
		Common.new_healthbar(true, e, Balance.cannon_starting_hp, nil, e.health, 0.3, -0.1, memory.boat)
	end

	boat.dockedposition = boat.position
	boat.speed = 0
	boat.cannonscount = 2
end


function Public.summon_crew()
	local memory = Memory.get_crew_memory()
	local boat = memory.boat

	local print = false
	for _, player in pairs(game.connected_players) do
		if player.surface and player.surface.valid and boat.surface_name and player.surface.name == boat.surface_name and (not Boats.on_boat(boat, player.position)) then
			local p = player.surface.find_non_colliding_position('character', memory.spawnpoint, 5, 0.1)
			if p then
				player.teleport(p)
			else
				player.teleport(memory.spawnpoint)
			end
			print = true
		end
	end
	if print then
		Common.notify_force(memory.force, {'pirates.crew_summon'})
	end
end


function Public.reset_crew_and_enemy_force(id)
	local crew_force = game.forces[Common.get_crew_force_name(id)]
	local enemy_force = game.forces[Common.get_enemy_force_name(id)]
	local ancient_friendly_force = game.forces[Common.get_ancient_friendly_force_name(id)]
	local ancient_enemy_force = game.forces[Common.get_ancient_hostile_force_name(id)]

	crew_force.reset()
	enemy_force.reset()
	ancient_friendly_force.reset()
	ancient_enemy_force.reset()

    ancient_enemy_force.set_turret_attack_modifier('gun-turret', 0.2)

	enemy_force.reset_evolution()
	for _, tech in pairs(crew_force.technologies) do
		crew_force.set_saved_technology_progress(tech, 0)
	end
	local lobby = game.surfaces[CoreData.lobby_surface_name]
	crew_force.set_spawn_position(Common.lobby_spawnpoint, lobby)

	enemy_force.ai_controllable = true



	crew_force.set_friend('player', true)
	game.forces['player'].set_friend(crew_force, true)
	crew_force.set_friend(ancient_friendly_force, true)
	ancient_friendly_force.set_friend(crew_force, true)
	enemy_force.set_friend(ancient_friendly_force, true)
	ancient_friendly_force.set_friend(enemy_force, true)
	enemy_force.set_friend(ancient_enemy_force, true)
	ancient_enemy_force.set_friend(enemy_force, true)

	-- enemy_force.set_friend(environment_force, true)
	-- environment_force.set_friend(enemy_force, true)

	-- environment_force.set_friend(ancient_enemy_force, true)
	-- ancient_enemy_force.set_friend(environment_force, true)

	-- environment_force.set_friend(ancient_friendly_force, true)
	-- ancient_friendly_force.set_friend(environment_force, true)

	-- maybe make these dependent on map... it could be slower to mine on poor maps, so that players jump more often rather than getting every last drop
	crew_force.mining_drill_productivity_bonus = 1
	-- crew_force.mining_drill_productivity_bonus = 1.25
	crew_force.manual_mining_speed_modifier = 3
	crew_force.character_inventory_slots_bonus = 0
	-- crew_force.character_inventory_slots_bonus = 10
	-- crew_force.character_running_speed_modifier = Balance.base_extra_character_speed
	crew_force.laboratory_productivity_bonus = 0
	crew_force.ghost_time_to_live = 12 * 60 * 60

	for k, v in pairs(Balance.player_ammo_damage_modifiers()) do
		crew_force.set_ammo_damage_modifier(k, v)
	end
	for k, v in pairs(Balance.player_gun_speed_modifiers()) do
		crew_force.set_gun_speed_modifier(k, v)
	end
	for k, v in pairs(Balance.player_turret_attack_modifiers()) do
		crew_force.set_turret_attack_modifier(k, v)
	end

	crew_force.technologies['circuit-network'].researched = true
	crew_force.technologies['uranium-processing'].researched = true
	crew_force.technologies['kovarex-enrichment-process'].researched = true
	crew_force.technologies['gun-turret'].researched = true
	crew_force.technologies['electric-energy-distribution-1'].researched = true
	crew_force.technologies['electric-energy-distribution-2'].researched = true
	crew_force.technologies['advanced-material-processing'].researched = true
	crew_force.technologies['advanced-material-processing-2'].researched = true
	crew_force.technologies['solar-energy'].researched = true
	crew_force.technologies['inserter-capacity-bonus-1'].researched = true --needed to make stack inserters different to fast inserters
	-- crew_force.technologies['inserter-capacity-bonus-2'].researched = true

	--as prerequisites for uranium ammo and automation 3:
	crew_force.technologies['speed-module'].researched = true
	crew_force.technologies['tank'].researched = true
	crew_force.recipes['speed-module'].enabled = false
	crew_force.recipes['tank'].enabled = false
	crew_force.recipes['cannon-shell'].enabled = false
	crew_force.recipes['explosive-cannon-shell'].enabled = false



	--@TRYING this out:
	crew_force.technologies['coal-liquefaction'].enabled = true
	crew_force.technologies['coal-liquefaction'].researched = true

	crew_force.technologies['automobilism'].enabled = false

	crew_force.technologies['toolbelt'].enabled = false --trying this. we don't actually want players to carry too many things manually, and in fact in a resource-tight scenario that's problematic

	-- note: many of these recipes are overwritten after tech researched!!!!!!! like pistol. check elsewhere in code

	crew_force.recipes['pistol'].enabled = false

	-- these are redundant I think...?:
	crew_force.recipes['centrifuge'].enabled = false
	crew_force.recipes['flamethrower-turret'].enabled = false

	crew_force.technologies['railway'].researched = true --needed for purple sci
	crew_force.recipes['rail'].enabled = true --needed for purple sci
	crew_force.recipes['locomotive'].enabled = false
	crew_force.recipes['car'].enabled = false
	crew_force.recipes['cargo-wagon'].enabled = false

	crew_force.recipes['nuclear-fuel'].enabled = false -- reduce clutter

	-- crew_force.recipes['underground-belt'].enabled = false
	-- crew_force.recipes['fast-underground-belt'].enabled = false
	-- crew_force.recipes['express-underground-belt'].enabled = false

	crew_force.technologies['land-mine'].enabled = false
	crew_force.technologies['landfill'].enabled = false
	crew_force.technologies['cliff-explosives'].enabled = false

	crew_force.technologies['rail-signals'].enabled = false

	crew_force.technologies['logistic-system'].enabled = false


	crew_force.technologies['tank'].enabled = false
	crew_force.technologies['rocketry'].enabled = false
	crew_force.technologies['artillery'].enabled = false
	crew_force.technologies['destroyer'].enabled = false
	crew_force.technologies['spidertron'].enabled = false
	crew_force.technologies['atomic-bomb'].enabled = false
	crew_force.technologies['explosive-rocketry'].enabled = false

	crew_force.technologies['research-speed-1'].enabled = false
	crew_force.technologies['research-speed-2'].enabled = false
	crew_force.technologies['research-speed-3'].enabled = false
	crew_force.technologies['research-speed-4'].enabled = false
	crew_force.technologies['research-speed-5'].enabled = false
	crew_force.technologies['research-speed-6'].enabled = false
	-- crew_force.technologies['follower-robot-count-1'].enabled = false
	-- crew_force.technologies['follower-robot-count-2'].enabled = false
	-- crew_force.technologies['follower-robot-count-3'].enabled = false
	-- crew_force.technologies['follower-robot-count-4'].enabled = false

	-- crew_force.technologies['inserter-capacity-bonus-3'].enabled = false
	-- crew_force.technologies['inserter-capacity-bonus-4'].enabled = false
	-- crew_force.technologies['inserter-capacity-bonus-5'].enabled = false
	-- crew_force.technologies['inserter-capacity-bonus-6'].enabled = false
	-- crew_force.technologies['refined-flammables-3'].enabled = false
	-- crew_force.technologies['refined-flammables-4'].enabled = false
	-- crew_force.technologies['refined-flammables-5'].enabled = false

	-- for lategame balance:
	-- crew_force.technologies['worker-robots-storage-1'].enabled = false
	crew_force.technologies['worker-robots-storage-2'].enabled = false
	crew_force.technologies['worker-robots-storage-3'].enabled = false
	crew_force.technologies['worker-robots-speed-5'].enabled = false
	crew_force.technologies['worker-robots-speed-6'].enabled = false
	crew_force.technologies['follower-robot-count-5'].enabled = false
	crew_force.technologies['follower-robot-count-6'].enabled = false
	crew_force.technologies['follower-robot-count-7'].enabled = false
	crew_force.technologies['inserter-capacity-bonus-6'].enabled = false
	crew_force.technologies['inserter-capacity-bonus-7'].enabled = false

	crew_force.technologies['weapon-shooting-speed-6'].enabled = false
	crew_force.technologies['laser-shooting-speed-6'].enabled = false
	crew_force.technologies['laser-shooting-speed-7'].enabled = false
	crew_force.technologies['refined-flammables-5'].enabled = false
	crew_force.technologies['refined-flammables-6'].enabled = false
	crew_force.technologies['refined-flammables-7'].enabled = false
	crew_force.technologies['energy-weapons-damage-5'].enabled = false --5 makes krakens too easy
	crew_force.technologies['energy-weapons-damage-6'].enabled = false
	crew_force.technologies['energy-weapons-damage-7'].enabled = false
	crew_force.technologies['physical-projectile-damage-5'].enabled = false
	crew_force.technologies['physical-projectile-damage-6'].enabled = false
	crew_force.technologies['physical-projectile-damage-7'].enabled = false
	crew_force.technologies['stronger-explosives-5'].enabled = false
	crew_force.technologies['stronger-explosives-6'].enabled = false
	crew_force.technologies['stronger-explosives-7'].enabled = false
	-- these require 2000 white sci each:
	crew_force.technologies['artillery-shell-range-1'].enabled = false --infinite techs
	crew_force.technologies['artillery-shell-speed-1'].enabled = false --infinite techs

	crew_force.technologies['steel-axe'].enabled = false

	crew_force.technologies['concrete'].enabled = false
	crew_force.technologies['nuclear-power'].enabled = false

	crew_force.technologies['effect-transmission'].enabled = true

	-- exploit?:
	crew_force.technologies['gate'].enabled = true

	crew_force.technologies['productivity-module-2'].enabled = true
	crew_force.technologies['productivity-module-3'].enabled = false
	crew_force.technologies['speed-module'].enabled = true
	crew_force.technologies['speed-module-2'].enabled = false
	crew_force.technologies['speed-module-3'].enabled = false
	crew_force.technologies['effectivity-module'].enabled = false
	crew_force.technologies['effectivity-module-2'].enabled = false
	crew_force.technologies['effectivity-module-3'].enabled = false
	crew_force.technologies['automation-3'].enabled = true
	crew_force.technologies['rocket-control-unit'].enabled = false
	crew_force.technologies['rocket-silo'].enabled = false
	crew_force.technologies['space-science-pack'].enabled = false
	crew_force.technologies['mining-productivity-4'].enabled = false
	crew_force.technologies['logistics-3'].enabled = true
	crew_force.technologies['nuclear-fuel-reprocessing'].enabled = false

	-- crew_force.technologies['railway'].enabled = false
	crew_force.technologies['automated-rail-transportation'].enabled = false
	crew_force.technologies['braking-force-1'].enabled = false
	crew_force.technologies['braking-force-2'].enabled = false
	crew_force.technologies['braking-force-3'].enabled = false
	crew_force.technologies['braking-force-4'].enabled = false
	crew_force.technologies['braking-force-5'].enabled = false
	crew_force.technologies['braking-force-6'].enabled = false
	crew_force.technologies['braking-force-7'].enabled = false
	crew_force.technologies['fluid-wagon'].enabled = false

	crew_force.technologies['production-science-pack'].enabled = true
	crew_force.technologies['utility-science-pack'].enabled = true

	crew_force.technologies['modular-armor'].enabled = false
	crew_force.technologies['power-armor'].enabled = false
	crew_force.technologies['solar-panel-equipment'].enabled = false
	crew_force.technologies['personal-roboport-equipment'].enabled = false
	crew_force.technologies['personal-laser-defense-equipment'].enabled = false
	crew_force.technologies['night-vision-equipment'].enabled = false
	crew_force.technologies['energy-shield-equipment'].enabled = false
	crew_force.technologies['belt-immunity-equipment'].enabled = false
	crew_force.technologies['exoskeleton-equipment'].enabled = false
	crew_force.technologies['battery-equipment'].enabled = false
	crew_force.technologies['fusion-reactor-equipment'].enabled = false
	crew_force.technologies['power-armor-mk2'].enabled = false
	crew_force.technologies['energy-shield-mk2-equipment'].enabled = false
	crew_force.technologies['personal-roboport-mk2-equipment'].enabled = false
	crew_force.technologies['battery-mk2-equipment'].enabled = false
	crew_force.technologies['discharge-defense-equipment'].enabled = false

	crew_force.technologies['distractor'].enabled = false
	crew_force.technologies['military-4'].enabled = true
	crew_force.technologies['uranium-ammo'].enabled = true
end



return Public