global

def self.write_map(original_files_paths, maps_path, output_path, shuffle_level, romanize, logging, game_type)
    maps_object_map = Hash[original_files_paths.map { |f| [File.basename(f), Marshal.load(File.binread(f))] }]

    # @type [Array<String>]
    maps_original_text =
        File
            .readlines(File.join(maps_path, 'maps.txt'), encoding: 'UTF-8', chomp: true)
            .map { |line| line.gsub('\#', "\n").strip }
            .freeze

    # @type [Array<String>]
    names_original_text =
        File
            .readlines(File.join(maps_path, 'names.txt'), encoding: 'UTF-8', chomp: true)
            .map { |line| line.gsub('\#', "\n").strip }
            .freeze

    # @type [Array<String>]
    maps_translated_text =
        File
            .readlines(File.join(maps_path, 'maps_trans.txt'), encoding: 'UTF-8', chomp: true)
            .map { |line| line.gsub('\#', "\n").strip }

    # @type [Array<String>]
    names_translated_text =
        File
            .readlines(File.join(maps_path, 'names_trans.txt'), encoding: 'UTF-8', chomp: true)
            .map { |line| line.gsub('\#', "\n").strip }

    if shuffle_level.positive?
        maps_translated_text.shuffle!
        names_translated_text.shuffle!

        if shuffle_level == 2
            maps_translated_text = shuffle_words(maps_translated_text)
            names_translated_text = shuffle_words(names_translated_text)
        end
    end

    # @type [Hash{String => String}]
    maps_translation_map = Hash[maps_original_text.zip(maps_translated_text)].freeze
    # @type [Hash{String => String}]
    names_translation_map = Hash[names_original_text.zip(names_translated_text)].freeze

    # @type [Array<Integer>]
    # 401 - dialogue lines
    # 102 - dialogue choices array
    # 402 - one of the dialogue choices from the array
    # 356 - system lines/special texts (do they even exist before mv?)
    allowed_codes = [102, 320, 324, 356, 401, 402].freeze

    maps_object_map.each do |filename, object|
        # @type [String]
        display_name = object.display_name
        display_name_translated = names_translation_map[display_name]
        object.display_name = display_name_translated if display_name_translated

        events = object.events
        next unless events

        events.each do |ev, event|
            pages = event.pages
            next unless pages

            pages.each_with_index do |page, pg|
                list = page.list
                next unless list

                in_sequence = false
                # @type [Array<String>]
                line = []
                # @type [Array<Integer>]
                item_indices = []

                list.each_with_index do |item, it|
                    # @type [Integer]
                    code = item.code

                    if in_sequence && code != 401
                        unless line.empty?
                            joined = line.join("\n").strip
                            joined = romanize_string(joined) if romanize

                            translated = get_parameter_translated(401, joined, maps_translation_map, game_type)

                            if translated && !translated.empty?
                                split = translated.split('\#')

                                split_length = split.length
                                line_length = line.length

                                item_indices.each_with_index { |index, i| list[index].parameters[0] = i < split_length ? split[i] : '' }

                                if split_length > line_length
                                    list[item_indices.last].parameters[0] = split[line_length - 1..].join("\n")
                                end
                            end

                            line.clear
                        end

                        in_sequence = false
                    end

                    next unless allowed_codes.include?(code)

                    # @type [Array<String>]
                    parameters = item.parameters

                    case code
                    when 401
                        # @type [String]
                        parameter = parameters[0]
                        next unless parameter.is_a?(String)

                        parameter = convert_to_utf8(parameter)

                        in_sequence = true
                        line.push(parameter.gsub('　', ' ').strip)
                        item_indices.push(it)
                    when 102
                        parameters[0].each_with_index do |subparameter, sp|
                            next unless subparameter.is_a?(String)

                            subparameter = subparameter.strip
                            next if subparameter.empty?

                            subparameter = convert_to_utf8(subparameter)
                            subparameter = romanize_string(subparameter.strip) if romanize

                            translated = get_parameter_translated(code, subparameter, maps_translation_map, game_type)
                            parameters[0][sp] = translated if translated && !translated.empty?
                        end
                    when 356
                        # @type [String]
                        parameter = parameters[0]
                        next unless parameter.is_a?(String)

                        parameter = parameter.strip
                        next if parameter.empty?

                        parameter = convert_to_utf8(parameter)
                        parameter = romanize_string(parameter) if romanize

                        translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
                        parameters[0] = translated if translated && !translated.empty?
                    when 320, 324, 402
                        # @type [String]
                        parameter = parameters[1]
                        next unless parameter.is_a?(String)

                        parameter = parameter.strip
                        next if parameter.empty?

                        parameter = convert_to_utf8(parameter)
                        parameter = romanize_string(parameters[1].strip) if romanize

                        translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
                        parameters[1] = translated if translated && !translated.empty?
                    end

                    item.parameters = parameters
                    list[it] = item
                end

                page.list = list
                pages[pg] = page
            end

            event.pages = pages
            events[ev] = event
        end

        object.events = events

        File.binwrite(File.join(output_path, filename), Marshal.dump(object))
        puts "Written #{filename}" if logging
    end
end