221 lines
7.1 KiB
Lua
221 lines
7.1 KiB
Lua
--- @diagnostic disable
|
|
--- @deprecated use `dictionary` instead
|
|
local flib_translation = {}
|
|
|
|
local table = require("__flib__/table")
|
|
|
|
local math = math
|
|
local next = next
|
|
local pairs = pairs
|
|
local type = type
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.init()
|
|
if not global.__flib then
|
|
global.__flib = {}
|
|
end
|
|
global.__flib.translation = {
|
|
players = {},
|
|
translating_players_count = 0,
|
|
}
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.iterate_batch(event_data)
|
|
local __translation = global.__flib.translation
|
|
if __translation.translating_players_count == 0 then
|
|
return
|
|
end
|
|
local iterations = math.ceil(5 / __translation.translating_players_count)
|
|
if iterations < 1 then
|
|
iterations = 1
|
|
end
|
|
local current_tick = event_data.tick
|
|
|
|
for player_index, player_table in pairs(__translation.players) do
|
|
local player = game.get_player(player_index)
|
|
if player.connected then
|
|
local request_translation = player.request_translation
|
|
local i = 0
|
|
local sort_data = player_table.sort
|
|
local sort_strings = sort_data and sort_data.strings
|
|
local translate_data = player_table.translate
|
|
local translate_strings = translate_data.strings
|
|
while i < iterations do
|
|
if player_table.state == "sort" then
|
|
local string_index = sort_data.next_index
|
|
local string_data = sort_strings[string_index]
|
|
if string_data then
|
|
i = i + 1
|
|
local serialised = flib_translation.serialise_localised_string(string_data.localised)
|
|
local translation_data = translate_strings[serialised]
|
|
if translation_data then
|
|
local dictionary_names = translation_data.names[string_data.dictionary]
|
|
if dictionary_names then
|
|
dictionary_names[#dictionary_names + 1] = string_data.internal
|
|
else
|
|
translation_data.names[string_data.dictionary] = { string_data.internal }
|
|
end
|
|
else
|
|
translate_strings[serialised] = {
|
|
string = string_data.localised,
|
|
names = { [string_data.dictionary] = { string_data.internal } },
|
|
}
|
|
translate_strings.__size = translate_strings.__size + 1
|
|
end
|
|
sort_data.next_index = string_index + 1
|
|
sort_strings[string_index] = nil
|
|
else
|
|
player_table.state = "translate"
|
|
player_table.sort = nil
|
|
player_table.translate.next_key = next(player_table.translate.strings, "__size")
|
|
end
|
|
elseif player_table.state == "translate" then
|
|
local current_key = translate_data.next_key
|
|
local translation_data = translate_strings[current_key]
|
|
if translation_data then
|
|
i = i + 1
|
|
request_translation(translation_data.string)
|
|
translate_data.next_key = next(translate_strings, current_key)
|
|
else
|
|
player_table.state = "wait"
|
|
player_table.translate.current_key = nil
|
|
end
|
|
elseif player_table.state == "wait" then
|
|
local wait_tick = player_table.wait_tick
|
|
if wait_tick then
|
|
if wait_tick <= current_tick then
|
|
-- if this player is still being iterated at this point, there are some unreceived translations
|
|
-- see https://forums.factorio.com/84570
|
|
player_table.state = "translate"
|
|
player_table.translate.next_key = next(translate_strings, "__size")
|
|
end
|
|
else
|
|
player_table.wait_tick = current_tick + 20
|
|
end
|
|
break -- only needs to run once per player per tick
|
|
end
|
|
end
|
|
else
|
|
flib_translation.cancel(player_index)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.process_result(event_data)
|
|
local __translation = global.__flib.translation
|
|
if __translation.translating_players_count == 0 then
|
|
return
|
|
end
|
|
local player_table = __translation.players[event_data.player_index]
|
|
if not player_table then
|
|
return
|
|
end
|
|
if player_table.state == "sort" then
|
|
return
|
|
end
|
|
|
|
local serialised = flib_translation.serialise_localised_string(event_data.localised_string)
|
|
local translate_strings = player_table.translate.strings
|
|
|
|
local translation_data = translate_strings[serialised]
|
|
if translation_data then
|
|
local names = translation_data.names
|
|
translate_strings[serialised] = nil
|
|
translate_strings.__size = translate_strings.__size - 1
|
|
local finished = false
|
|
if translate_strings.__size == 0 then
|
|
flib_translation.cancel(event_data.player_index)
|
|
finished = true
|
|
end
|
|
return names, finished
|
|
end
|
|
return nil, false
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.add_requests(player_index, strings)
|
|
local __translation = global.__flib.translation
|
|
local player_table = __translation.players[player_index]
|
|
if player_table then
|
|
player_table.state = "sort"
|
|
if player_table.sort then
|
|
local strings_to_sort = player_table.sort.strings
|
|
for i = 1, #strings do
|
|
strings_to_sort[#strings_to_sort + 1] = strings[i]
|
|
end
|
|
player_table.sort.next_index = 1
|
|
else
|
|
player_table.sort = {
|
|
strings = table.shallow_copy(strings),
|
|
next_index = 1,
|
|
}
|
|
end
|
|
player_table.translate.next_key = nil
|
|
else
|
|
__translation.players[player_index] = {
|
|
state = "sort",
|
|
-- sort
|
|
sort = {
|
|
strings = table.shallow_copy(strings),
|
|
next_index = 1,
|
|
},
|
|
-- translate
|
|
translate = {
|
|
strings = { __size = 0 },
|
|
next_key = nil,
|
|
},
|
|
-- wait
|
|
wait_tick = nil,
|
|
}
|
|
__translation.translating_players_count = __translation.translating_players_count + 1
|
|
end
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.cancel(player_index)
|
|
local __translation = global.__flib.translation
|
|
local player_table = __translation.players[player_index]
|
|
if not player_table then
|
|
log("Tried to cancel translations for player [" .. player_index .. "] when no translations were running!")
|
|
return
|
|
end
|
|
__translation.players[player_index] = nil
|
|
__translation.translating_players_count = __translation.translating_players_count - 1
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.is_translating(player_index)
|
|
return global.__flib.translation.players[player_index] and true or false
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.translating_players_count()
|
|
return global.__flib.translation.translating_players_count
|
|
end
|
|
|
|
--- @deprecated use `dictionary` instead
|
|
function flib_translation.serialise_localised_string(localised_string)
|
|
if type(localised_string) == "string" then
|
|
return localised_string
|
|
end
|
|
local output = "{"
|
|
local first = true
|
|
for _, v in pairs(localised_string) do
|
|
if not first then
|
|
output = output .. ","
|
|
end
|
|
if type(v) == "table" then
|
|
output = output .. flib_translation.serialise_localised_string(v)
|
|
else
|
|
output = output .. '"' .. tostring(v) .. '"'
|
|
end
|
|
first = false
|
|
end
|
|
output = output .. "}"
|
|
return output
|
|
end
|
|
|
|
return flib_translation
|