Factorio Forums

Code: Select all

function has_value(tab, val) for _, v in ipairs(tab) do if v == val then return true end end end
function B(f, g) return function(a) return f(g(a)) end end --[[Bluebird ( . )--]]
function map(a, f)
    local r = {}
    for i, c in ipairs(a) do table.insert(r, f(c, i, a)) end
    return r
end

Code: Select all

function typeFromName(name) return (data.raw.fluid[name] and 'fluid' or 'item') end
function norm(keys) return function(item)
    local n = {}
    for k, v in pairs(keys) do if string.find(k, '^%d+$') then n[v] = item[v] or item[k] elseif not n[k] then n[k] = v end end
    for k, v in pairs(item) do if not string.find(k, '^%d+$') then n[k] = v end end
    return n
end end
function rdata(recipe)
    if not recipe then return nil end
    local r = {}
    local b = B(norm{'name', 'count', count = 1}, function(item) item.type = typeFromName(item.name) return item end)
    r.results = map(recipe.results or ({{recipe.result, recipe.result_count}}), b)
    r.ingredients = map(recipe.ingredients, b)
    return r
end
local general_data = {'category', 'subgroup', 'crafting_machine_tint', 'type', 'name', 'order', 'localised_name', 'localised_description',}
function normalize_recipe(recipe)
    local r = {}
    recipe = table.deepcopy(recipe)
    r.normal = rdata(recipe.normal)
    r.expensive = rdata(recipe.expensive) or table.deepcopy(r.normal)
    for k, v in pairs(recipe) do if has_value(general_data, k) then r[k] = v end end
    if not r.normal and not r.expensive then r.expensive = rdata(recipe) end
    r.normal = r.normal or table.deepcopy(r.expensive)
    r.icons = (recipe.icon or recipe.icons) and map(recipe.icons or {{recipe.icon, recipe.icon_size}}, norm{'icon', 'icon_size', icon_size = 32}) or nil
    return r
end

Code: Select all

function promise(f2,f1)
  return function(arg)
    return f2( f1(arg) )
    end
  end

function map (tableA,f)
  local new = {}
  for index, value in ipairs(tableA) do
    table.insert(new, f(value, index, tableA))
    end
  return new
  end
  
function reformat (item) --no good name for this
  local new = {}
  for k,v in pairs(item_defaults)       do
    if string.find(k, '^%d+$') then --if type(k) == 'number' then
      new[v] = item[v] or item[k]
    elseif (not new[k]) then
      new[k] = v
      end
    end
  for k, v in pairs(item) do
    if not string.find(k, '^%d+$') then
      new[k] = v
      end
    end
  return new
  end

function add_type(item)
  item.type = data.raw.fluid[item.name] and 'fluid' or 'item'
  return item
  end
  
local non_difficulty_data = {
  'name'                  = true,
  'type'                  = true,
  'order'                 = true,
  'localised_name'        = true,
  'localised_description' = true,
  'crafting_machine_tint' = true,
  'category'              = true,
  'subgroup'              = true,
  }
  
function difficulty_data(difficulty)
  if (difficulty == nil) then return end
  local new = {}
  local normalize_and_type = promise(reformat({'name', 'count', count = 1}), add_type)
  new.results = map(
    difficulty.results or {{difficulty.result, difficulty.result_count}},
    normalize_and_type
    )
  new.ingredients = map(
    recipe.ingredients,
    normalize_and_type
    )
  return new
  end

local deepcopy = util.table.deepcopy
function normalize_recipe(old_recipe)
  local new     = {}
  old_recipe    = deepcopy(old_recipe)
  new.normal    = difficulty_data(recipe.normal   )
  new.expensive = difficulty_data(recipe.expensive) or deepcopy(new.normal)
  for k,v in pairs(old_recipe) do
    if non_difficulty_data[k] then
      new[k] = v
      end
    end
  if not (new.normal or new.expensive) then
    new.expensive = difficulty_data(old_recipe)
    end
  new.normal    = new.normal or deepcopy(new.expensive)
  new.icons     = not (recipe.icon or recipe.icons) and nil or map(
    recipe.icons or {{recipe.icon, recipe.icon_size}},
    reformat{'icon', 'icon_size', icon_size = 32}
    )
  if old_recipe.normal    == false then new.normal   .enabled = false end
  if old_recipe.expensive == false then new.expensive.enabled = false end
  return new
  end

Code: Select all

local B = function(f) return function(g) return function(a) return f(g(a)) end end end

Code: Select all

let B = f=>g=>a=> f(g(a))

Code: Select all

B f g a = f (g a)
B = ( . ) -- or just use the built in function

Code: Select all

local a = {}
a[1] = 'x'
a['1'] = 'y'
game.print(serpent.block(a))

Code: Select all

game.table_to_json(a) 

Code: Select all

function compose(f, g) return function(arg)
    return f(g(arg))
end end

function map(array, f)
    local new = {}
    for i, v in ipairs(array) do
        table.insert(new, f(v, i, array))
    end
    return new
end

function reformat(new_format) return function(item)
    local new = {}
    for k,v in pairs(new_format) do
        if type(k) == 'number' then new[v] = item[v] or item[k]
        elseif (not new[k])    then new[k] = v end
    end
    for k, v in pairs(item) do
        if type(k) ~= 'number' then new[k] = v end
    end
    return new
end end

function add_type(item)
    item.type = data.raw.fluid[item.name] and 'fluid' or 'item'
    return item
end

local non_difficulty_data = {
    name                  = true,
    type                  = true,
    order                 = true,
    localised_name        = true,
    localised_description = true,
    crafting_machine_tint = true,
    category              = true,
    subgroup              = true,
}

function difficulty_data(difficulty)
    if (difficulty == nil) then return end
    local new = {}
    local normalize_and_type = compose(add_type, reformat{'name', 'amount', amount = 1})
    new.results = map(
        difficulty.results or {{difficulty.result, difficulty.result_count}},
        normalize_and_type
    )
    new.ingredients = map(
        difficulty.ingredients,
        normalize_and_type
    )
    return new
end

local deepcopy = util.table.deepcopy
function normalize_recipe(old_recipe)
    local new     = {}
    old_recipe    = deepcopy(old_recipe)
    new.normal    = difficulty_data(old_recipe.normal   )
    new.expensive = difficulty_data(old_recipe.expensive) or deepcopy(new.normal)
    for k,v in pairs(old_recipe) do
        if non_difficulty_data[k] then new[k] = v end
    end
    if not (new.normal or new.expensive) then
        new.expensive = difficulty_data(old_recipe)
    end
    new.normal    = new.normal or deepcopy(new.expensive)
    new.icons     = not (old_recipe.icon or old_recipe.icons) and nil or map(
        old_recipe.icons or {{old_recipe.icon, old_recipe.icon_size}},
        reformat{'icon', 'icon_size', icon_size = 32}
    )
    if old_recipe.normal    == false then new.normal   .enabled = false end
    if old_recipe.expensive == false then new.expensive.enabled = false end
    return new
end

Code: Select all

function enforce_format(new_format) return function(difficulty)
  local new = deepcopy(new_format)
  for k,v in pairs(difficulty) do
    if new[k] ~= nil then
      new[k] = v
      end
    end
  return new
  end
end

local difficulty_defaults = {
  energy_required            = 0.5   ,
  emissions_multiplier       = 1.0   ,
  requester_paste_multiplier = 30    ,
  overload_multiplier        = 0     ,
  enabled                    = true  ,
  hidden                     = false ,
  hide_from_stats            = false ,
  allow_decomposition        = true  ,
  allow_as_intermediate      = true  ,
  allow_intermediates        = true  ,
  always_show_made_in        = false ,
  show_amount_in_title       = true  ,
  always_show_products       = false ,
  main_product               = nil   , --for completeness
  }

function difficulty_data(difficulty)
    if (difficulty == nil) then return end
    
    local new = enforce_format(difficulty_defaults)(difficulty)
    new.main_product = difficulty.main_product --because enforce_format doesn't handle nil defaults

    local normalize_and_type = compose(add_type, reformat{'name', 'amount'})
    new.results = map(
        difficulty.results or {{difficulty.result, difficulty.result_count}},
        normalize_and_type
    )
    new.ingredients = map(
        difficulty.ingredients,
        normalize_and_type
    )    
    return new
end