production-score.lua

local util = require("util")

local function get_total_production_counts(production_statistics)
  local produced = production_statistics.input_counts
  local consumed = production_statistics.output_counts
  for name, value in pairs (consumed) do
    if produced[name] then
      produced[name] = produced[name] - value
    else
      produced[name] = -value
    end
  end
  return produced
end

local function get_raw_resources()
  local raw_resources = {}
  local entities = game.entity_prototypes
  for name, entity_prototype in pairs (entities) do
    if entity_prototype.resource_category then
      if entity_prototype.mineable_properties and entity_prototype.mineable_properties.products then
        for k, product in pairs (entity_prototype.mineable_properties.products) do
          raw_resources[product.name] = true
        end
      end
    end
    if entity_prototype.fluid then
      raw_resources[entity_prototype.fluid.name] = true
    end
  end
  return raw_resources
end

local function get_product_list()
  local product_list = {}
  local recipes = game.recipe_prototypes

  for recipe_name, recipe_prototype in pairs (recipes) do
    if recipe_prototype.allow_decomposition then
      local ingredients = recipe_prototype.ingredients
      local products = recipe_prototype.products
      for k, product in pairs (products) do
        if not product_list[product.name] then
          product_list[product.name] = {}
        end
        local recipe_ingredients = {}
        local product_amount = util.product_amount(product)
        if product_amount > 0 then
          for j, ingredient in pairs (ingredients) do
            recipe_ingredients[ingredient.name] = ((ingredient.amount)/#products) / product_amount
          end
          recipe_ingredients.energy = (recipe_prototype.energy / #products) / product_amount
          table.insert(product_list[product.name], recipe_ingredients)
        end
      end
    end
  end

  local items = game.item_prototypes
  local entities = game.entity_prototypes
  --[[Now we do some tricky stuff for space science type items]]
  local rocket_silos = {}
  for k, entity in pairs (entities) do
    if entity.type == "rocket-silo" and entity.fixed_recipe then
      local recipe = recipes[entity.fixed_recipe]
      if not recipe then return end
      local required_parts = entity.rocket_parts_required
      local list = {}
      for k, product in pairs (recipe.products) do
        local product_amount = util.product_amount(product)
        if product_amount > 0 then
          product_amount = product_amount * required_parts
          list[product.name] = product_amount
        end
      end
      list["energy"] = recipe.energy
      table.insert(rocket_silos, list)
    end
  end
  for k, item in pairs (items) do
    local launch_products = item.rocket_launch_products
    if launch_products then
      for k, launch_product in pairs (launch_products) do
        product_list[launch_product.name] = product_list[launch_product.name] or {}
        local launch_product_amount = util.product_amount(launch_product)
        if launch_product_amount > 0 then
          for k, silo_products in pairs (rocket_silos) do
            local this_silo = {}
            for product_name, product_count in pairs (silo_products) do
              this_silo[product_name] = product_count / launch_product_amount
            end
            this_silo[item.name] = 1 / launch_product_amount
            table.insert(product_list[launch_product.name], this_silo)
          end
        end
      end
    end
  end
  return product_list
end

local default_seed_prices = function()
  return
  {
    ["iron-ore"] = 3.1,
    ["copper-ore"] = 3.6,
    ["coal"] = 3,
    ["stone"] = 2.4,
    ["crude-oil"] = 0.2,
    ["water"] = 1/1000,
    ["steam"] = 1/1000,
    ["wood"] = 3.2,
    ["raw-fish"] = 100,
    ["energy"] = 1,
    ["uranium-ore"] = 8.2
  }
end

local default_ingredient_exponent = function() return 1.025 end
local default_raw_resource_price = function() return 2.5 end
local default_resource_ignore = function() return {} end

local default_param = function()
  return
  {
    ingredient_exponent = 1.025, --[[The exponent for increase in value for each additional ingredient formula exponent^#ingredients-2]]
    raw_resource_price = 2.5, --[[If a raw resource isn't given a price, it uses this price]]
    resource_ignore = {} --[[This is used to account for mods removing resource generation, in which case we want the item price to be calculated from recipes.]]
  }
end

local ingredient_multiplier = function(recipe, param)
  return (param.ingredient_exponent or 1) ^ (table_size(recipe) - 2)
end

local deduce_nil_prices = function(price_list, param)
  local nil_prices = {}
  for name, item in pairs (game.item_prototypes) do
    if not price_list[name] then
      nil_prices[name] = {}
    end
  end
  for name, item in pairs (game.fluid_prototypes) do
    if not price_list[name] then
      nil_prices[name] = {}
    end
  end
  local recipes = game.recipe_prototypes
  for name, recipe in pairs (recipes) do
    for k, ingredient in pairs (recipe.ingredients) do
      if nil_prices[ingredient.name] then
        table.insert(nil_prices[ingredient.name], recipe)
      end
    end
  end
  for name, recipes in pairs (nil_prices) do
    if #recipes > 0 then
      local recipe_cost
      local ingredient_amount
      for k, recipe in pairs (recipes) do
        local ingredient_value = 0
        for k, ingredient in pairs (recipe.ingredients) do
          if ingredient.name == name then
            ingredient_amount = ingredient.amount
          else
            local ingredient_price = price_list[ingredient.name]
            if ingredient_price then
              ingredient_value = ingredient_value + (ingredient_price * ingredient.amount)
            else
              ingredient_value = nil
              break
            end
          end
        end
        if not ingredient_value then break end
        local product_value = 0
        for k, product in pairs (recipe.products) do
          local amount = util.product_amount(product)
          local product_price = price_list[product.name]
          if product_price then
            product_value = product_value + product_price * amount
          else
            product_value = nil
            break
          end
        end
        if not product_value then
          break
        end
        local reverse_price = (product_value - param.energy_addition(recipe, product_value)) / ingredient_multiplier(recipe.ingredients, param) -- Not perfect, but close enough
        local this_cost = (reverse_price - ingredient_value) / ingredient_amount
        if recipe_cost then
          recipe_cost = math.min(recipe_cost, this_cost)
        else
          recipe_cost = this_cost
        end
      end
      if recipe_cost then
        price_list[name] = param.round(recipe_cost)
      end
    end
  end
end

local ln = math.log
local default_energy_addition = function(recipe, cost)
  return ((ln(recipe.energy + 1) * (cost ^ 0.5)))
end

local default_rounding = function(number)
  return number
end

local production_score = {}

production_score.generate_price_list = function(param)

  local param = param or {}
  local price_list = param.seed_prices or default_seed_prices()

  param.ingredient_exponent = param.ingredient_exponent or default_ingredient_exponent()
  param.raw_resource_price = param.raw_resource_price or default_raw_resource_price()
  param.resource_ignore = param.resource_ignore or default_resource_ignore()
  param.round = param.round or default_rounding
  param.energy_addition = param.energy_addition or default_energy_addition
  param.normalise = param.normalise or function(number) return number end

  local resource_list = get_raw_resources()

  for name, k in pairs (resource_list) do
    if not price_list[name] then
      price_list[name] = param.round(param.raw_resource_price)
    end
  end

  for k, name in pairs (param.resource_ignore or {}) do
    price_list[name] = nil
  end

  local product_list = get_product_list()
  local get_price_recursive
  get_price_recursive = function(name, current_loop, loop_force)
    local price = price_list[name]
    if price then return price end
    price = 0
    if current_loop[name] then
      if loop_force then
        return param.raw_resource_price
      end
      return
    end
    current_loop[name] = true
    local entry = product_list[name]
    if not entry then return end
    local recipe_cost
    for k, recipe in pairs (entry) do
      local this_recipe_cost = 0
      for ingredient_name, cost in pairs (recipe) do
        if ingredient_name ~= "energy" then
          local addition = get_price_recursive(ingredient_name, current_loop, loop_force)
          if addition and addition > 0 then
            this_recipe_cost = this_recipe_cost + (addition * cost)
          else
            this_recipe_cost = 0
            break
          end
        end
      end
      if this_recipe_cost > 0 then
        this_recipe_cost = (this_recipe_cost * ingredient_multiplier(recipe, param)) + param.energy_addition(recipe, this_recipe_cost)
        if recipe_cost then
          recipe_cost = math.min(recipe_cost, this_recipe_cost)
        else
          recipe_cost = this_recipe_cost
        end
      end
    end
    if recipe_cost then
      price = param.round(recipe_cost)
      price_list[name] = price
      return price
    end
  end
  local items = game.item_prototypes
  for name, item in pairs (items) do
    local current_loop = {}
    get_price_recursive(name, current_loop)
  end
  local fluids = game.fluid_prototypes
  for name, fluid in pairs (fluids) do
    local current_loop = {}
    get_price_recursive(name, current_loop)
  end
  deduce_nil_prices(price_list, param)
  for name, item in pairs (items) do
    local current_loop = {}
    get_price_recursive(name, current_loop, true)
  end
  for name, fluid in pairs (fluids) do
    local current_loop = {}
    get_price_recursive(name, current_loop, true)
  end
  deduce_nil_prices(price_list, param)

  for k, price in pairs (price_list) do
    price_list[k] = param.normalise(price)
  end

  return price_list
end

production_score.get_production_scores = function(price_list)
  local price_list = price_list or production_score.generate_price_list()
  local scores = {}
  for k, force in pairs (game.forces) do
    local score = 0
    for name, value in pairs (get_total_production_counts(force.item_production_statistics)) do
      local price = price_list[name]
      if price then
        score = score + (price * value)
      end
    end
    for name, value in pairs (get_total_production_counts(force.fluid_production_statistics)) do
      local price = price_list[name]
      if price then
        score = score + (price * value)
      end
    end
    scores[force.name] = math.floor(score)
  end
  return scores
end

return production_score