some AL farm speeds changed between 2.0 -> 2.1

[jackandape]

Mod source

Mixed GitHub and Factorio Mod Portal

Operating system

=Windows 10

What kind of issue is this?

• Compatibility
• Locale (names, descriptions, unknown keys)
• Graphical
• Crash
• Progression
• Balance
• Pypostprocessing failure
• Other

What is the problem?

Due to a handful of legacy typos, the full speeds of some AL farms are inconsistent as the AL module system changed between versions 2.0 and 2.1.

Steps to reproduce

1. farm
2. module
3. read number

Additional context

these are the buildings that needed adjusting. All except the few below are due to calling the function like so: py.farm_speed_derived(MODULE_SLOTS, "trits-reef-mk01"), instead of: py.farm_speed_derived(MODULE_SLOTS, "trits-reef-mk01", base_module_speed, new_module_speed). py.farm_speed_derived would assume that the new_module_speed was given by the ratio of slots.

other offenders:

guar-gum-plantation-mk03 was wrong due to a typo which never set the default -100% speed

ralesia-mk3-4 were wrong due to a typo where the base_building given to py.farm_speed_derived was not the mk1 level building but the previous mk level.

Log file

No response

[jackandape]

I think that the ralesia typo should simply be fixed, changing the building speeds. the change would look like this: 1, 4, 9.1, 16.3 -> 1, 4, 9, 16

the code to reproduce the exact speeds of 2.0 is this:

data.raw["assembling-machine"]["ralesia-plantation-mk01"].effect_receiver = {base_effect = {speed = -1}, speed_limits = {low = -0.9999}}
data.raw["assembling-machine"]["ralesia-plantation-mk01"].crafting_speed = py.farm_speed20(MODULE_SLOTS * 1, FULL_CRAFTING_SPEED)
data.raw["assembling-machine"]["ralesia-plantation-mk01"].module_slots = MODULE_SLOTS * 1

data.raw["assembling-machine"]["ralesia-plantation-mk02"].effect_receiver = {base_effect = {speed = -1}, speed_limits = {low = -0.9999}}
data.raw["assembling-machine"]["ralesia-plantation-mk02"].crafting_speed = py.farm_speed_derived20(MODULE_SLOTS * 2, "ralesia-plantation-mk01")
data.raw["assembling-machine"]["ralesia-plantation-mk02"].module_slots = MODULE_SLOTS * 2

data.raw["assembling-machine"]["ralesia-plantation-mk03"].effect_receiver = {base_effect = {speed = -1}, speed_limits = {low = -0.9999}}
data.raw["assembling-machine"]["ralesia-plantation-mk03"].crafting_speed = py.farm_speed_derived20(MODULE_SLOTS * 3, "ralesia-plantation-mk02")
data.raw["assembling-machine"]["ralesia-plantation-mk03"].module_slots = MODULE_SLOTS * 3

data.raw["assembling-machine"]["ralesia-plantation-mk04"].effect_receiver = {base_effect = {speed = -1}, speed_limits = {low = -0.9999}}
data.raw["assembling-machine"]["ralesia-plantation-mk04"].crafting_speed = py.farm_speed_derived20(MODULE_SLOTS * 4, "ralesia-plantation-mk03")
data.raw["assembling-machine"]["ralesia-plantation-mk04"].module_slots = MODULE_SLOTS * 4

-- effect of N+1/b modules is now spread over N modules (where b is the speed bonus of one module)
data.raw["assembling-machine"]["ralesia-plantation-mk01"].crafting_speed = data.raw["assembling-machine"]["ralesia-plantation-mk01"].crafting_speed *
                                                                            (MODULE_SLOTS * 1 + 1/1) / (MODULE_SLOTS * 1)
data.raw["assembling-machine"]["ralesia-plantation-mk02"].crafting_speed = data.raw["assembling-machine"]["ralesia-plantation-mk02"].crafting_speed *
                                                                            (MODULE_SLOTS * 2 + 1/2) / (MODULE_SLOTS * 2)
data.raw["assembling-machine"]["ralesia-plantation-mk03"].crafting_speed = data.raw["assembling-machine"]["ralesia-plantation-mk03"].crafting_speed *
                                                                            (MODULE_SLOTS * 3 + 1/3) / (MODULE_SLOTS * 3)
data.raw["assembling-machine"]["ralesia-plantation-mk04"].crafting_speed = data.raw["assembling-machine"]["ralesia-plantation-mk04"].crafting_speed *
                                                                            (MODULE_SLOTS * 4 + 1/4) / (MODULE_SLOTS * 4)

[jackandape]

the math part.

$$\begin{aligned} &s \quad \textrm{machine base speed}\\\ &m \quad \textrm{number of modules}\\\ &b \quad \textrm{module speed bonus}\\\ &\mathbb{S} \quad \textrm{machine full speed with modules}\\\ \end{aligned}$$

for 2.0, the building counted as part of the modules:

$$\begin{aligned} &\mathbb{S} \equiv s (m b + 1)\\\ &\textrm{rearrange and identify with py.farm\_speed (2.0 version),}\\\ &s = \frac{\mathbb{S}}{1 + m b} = \frac{\mathbb{S}}{b}\frac{1}{m + 1/b} \\\ &\textrm{the expression for py.farm\_speed\_derived (2.0 version),}\\\ &s^\prime = \mathbb{S} \frac{m^\prime/m}{(m^\prime + 1/b^\prime)\cdot b}\\\ &\textrm{substituting}\\\ &\frac{1}{(m^\prime + 1/b^\prime)} = \frac{b^\prime s^\prime}{\mathbb{S^\prime}},\\\ &s^\prime = \frac{\mathbb{S}}{\mathbb{S}^\prime} \frac{m^\prime}{m} \frac{s^\prime b^\prime}{b}\\\ &\frac{\mathbb{S^\prime}}{\mathbb{S}} = \frac{m^\prime}{m} \frac{b^\prime}{b}. \end{aligned}$$

so the function py.farm_speed_derived would return a new base speed, $$s^\prime$$, such that the new full speed of the machine is faster than the base machine by a factor of module_count_ratio * module_speed_ratio. When no module speeds were given as inputs to this function it would take module_speed_ratio = module_count_ratio and compute the base speed such that $$\mathbb{S^\prime}/\mathbb{S} = (m^\prime / m)^2$$.

now in 2.1 the building does not contribute to the module effect, and the expression is,

$$\begin{aligned} \mathbb{S} &\equiv s m b\\\ &\textrm{to keep the same scaling: }\\\ \frac{\mathbb{S^\prime}}{\mathbb{S}} &= \frac{m^\prime}{m} \frac{b^\prime}{b} \Rightarrow s^\prime = s \end{aligned}$$

meaning the base speeds of the buildings should be constant.

[jackandape]

I was using a script to test that may be useful, so i'll paste it here. It logs the speeds & module speed info for all buildings with unified modules. Output format is meant to be copy-pasted into a spreadsheet and split by ';'.

/sc
local building_info = {}
for _, e in pairs(game.surfaces[1].find_entities_filtered{type = "assembling-machine"}) do
  local recipe = e.get_recipe()
  local modules = {}
  local module_counts = {}

  local inv = e.get_module_inventory()
  local module_sum = 0
  local last_module_name
  if inv then
    for i = 1, #inv do
      local stack = inv[i]
      if stack.valid_for_read then
        modules[#modules + 1] = stack.name

        if module_counts[stack.name] then
            module_counts[stack.name] = module_counts[stack.name] + 1
        else
            module_counts[stack.name] = 1
        end
      end
    end

    for module_name, module_count in pairs(module_counts) do
        local contribution = prototypes.item[module_name].module_effects.speed * module_count
        module_sum = module_sum + contribution
        last_module_name = module_name

        if module_count == #inv then
            building_info[e.name .. ';' .. module_name] = {e.crafting_speed, e.crafting_speed / (1 + e.speed_bonus), 1 + e.speed_bonus}
        end
    end

  end
end

local output_string = "\n"
for name, speed in pairs(building_info) do
    output_string = output_string .. name .. ";" .. table.concat(building_info[name],";") .. "\n"
end
log(output_string)