Factorio Forums

Code: Select all

function get_prototype_from_name(item_name)
  local item_prototype
  for prototype_type in pairs(defines.prototypes.item) do
    if data.raw[prototype_type] then
      item_prototype = data.raw[prototype_type][item_name]
    end
    if item_prototype then break end
  end
  return item_prototype
end

function find_recipe(item_name)
  local recipe_item_name, found_recipe, already_found
  for recipe_name, recipe in pairs(data.raw.recipe) do
    if recipe.subgroup == "fill-barrel" or recipe.subgroup == "empty-barrel" or recipe.category == "recycling" then
      goto continue -- Way too many, and doesn't make sense to check
    end
    recipe_item_name = recipe.results and #recipe.results==1 and recipe.results[1].name
    if recipe_item_name == item_name then
      if already_found then
        if found_recipe.category == "metallurgy" and recipe.category ~= "metallurgy" then
          -- prefer non-casting if possible
          found_recipe = recipe
        elseif recipe.category == "metallurgy" then --skip
        else
          log("already found "..item_name.." in recipe "..recipe.name.." and "..found_recipe.name)
        end
        -- TODO check every recipe weights, choose one (which?)
      else
        found_recipe = recipe
        already_found = true
      end
    end
      ::continue::
  end
  return found_recipe
end

--[[
Weight formula:
weight = sum of ingredients * ingredient_to_weight_coefficient (default 0.5)

rocket capacity = kg*1000 / weight -- 1000kg = rocket_lift_weight
if rocket capacity > stack size then
  rocket capacity = rocket capacity - (rocket capacity % stack size) -- round down to the nearest stack size (as long as its greater than 0)
if allow_productivity and rocket capacity > stack size then
  rrocket capacity = stack size
]]

function get_weight(recipe, item_prototype)
  if item_prototype.weight then
    return item_prototype.weight
  end
  if recipe == nil then -- no way to link an item to a recipe, only a recipe to an item. Horray
    recipe = find_recipe(item_prototype.name)
    if recipe == nil then -- item has no weight and no recipe, assuming default.
      return data.raw["utility-constants"]["default"].default_item_weight -- 100 = 0.1kg
    end
  end
  local calc_weight = 0
  for _, ingredient in pairs(recipe.ingredients) do
    if ingredient.type == "fluid" then -- fluids don't have weight (I think) and so weight is default*amount
      calc_weight = calc_weight + (ingredient.amount * data.raw["utility-constants"]["default"].default_item_weight) -- 100 = 0.1kg
    elseif ingredient.type == "item" then -- ingredients don't have linked recipes, so we'll have to find one
      calc_weight = calc_weight + (get_weight(nil, get_prototype_from_name(ingredient.name)) * ingredient.amount)
    end
  end
  if calc_weight == 0 then calc_weight = data.raw["utility-constants"]["default"].default_item_weight end -- empty recipe, default weight
  if item_prototype.ingredient_to_weight_coefficient then
    calc_weight = calc_weight * item_prototype.ingredient_to_weight_coefficient
  else
    calc_weight = calc_weight * 0.5 -- default ingredient_to_weight_coefficient
  end
  return calc_weight
end

-- This is adapted from "Total Productivity for belts, landfill & everything", comments are my own.
function enable_total_productivity()

  local item_name, success, result
  for recipe_name, recipe in pairs(data.raw.recipe) do
    item_name = recipe.results and #recipe.results==1 and recipe.results[1].name

    success, call_result = pcall(should_enable_prod, item_name) -- checking settings
    if not success then
      error(serpent.line({
        recipe = recipe,
        error = call_result,
      }))
    end

    if call_result and not recipe.allow_productivity then
      recipe.allow_productivity = true
      local item_prototype = get_prototype_from_name(item_name)
	    if item_prototype and not item_prototype.weight then -- if no weight, allowing productivity might change rocket capacity
        local item_weight = get_weight(recipe, item_prototype)
        local rocket_capacity = data.raw["utility-constants"]["default"].rocket_lift_weight / item_weight
        -- non productivity default
        if rocket_capacity > item_prototype.stack_size then
          item_prototype.weight = data.raw["utility-constants"]["default"].rocket_lift_weight / item_prototype.stack_size
        end
        -- productivity default
        --[[
        if rocket_capacity > item_prototype.stack_size then
          if rocket_capacity % item_prototype.stack_size ~= 0 then
            rocket_capacity = rocket_capacity - (rocket_capacity % item_prototype.stack_size)
            item_prototype.weight = data.raw["utility-constants"]["default"].rocket_lift_weight / rocket_capacity
          end
        end
        ]]
        -- Custom check to ensure it can fit in the rocket
        if rocket_capacity / item_prototype.stack_size > 20 then
          item_prototype.weight = data.raw["utility-constants"]["default"].rocket_lift_weight / (20*item_prototype.stack_size) -- limit capacity to 20 * stack size
        end
        
      end
    end
  end
end