control.lua

require "gui"

local shared = require "shared"
local update_rate = shared.update_rate
local update_slots = shared.update_slots
local compactify = shared.compactify
local validity_check = shared.validity_check
local combine_tempatures = shared.combine_tempatures

local function setup()
	storage.units = storage.units or {}

	if remote.interfaces["PickerDollies"] then
		remote.call("PickerDollies", "add_blacklist_name", "fluid-memory-unit", true)
		remote.call("PickerDollies", "add_blacklist_name", "fluid-memory-unit-combinator", true)
	end
end

script.on_init(setup)
script.on_configuration_changed(function()
	setup()

	for unit_number, unit_data in pairs(storage.units) do
		if unit_data.item and not validity_check(unit_number, unit_data) then
			if not prototypes.fluid[unit_data.item] then shared.memory_unit_corruption(unit_number, unit_data) end
		end
	end
end)

local min = math.min
local function render_fluid_animation(item, entity)
	local color = prototypes.fluid[item].base_color
	rendering.draw_animation {
		animation = "fluid-memory-unit-animation",
		tint = {
			min(0.9, color.r + 0.2),
			min(0.9, color.g + 0.2),
			min(0.9, color.b + 0.2)
		},
		render_layer = "higher-object-above",
		target = entity,
		surface = entity.surface_index
	}
end

local function update_unit_exterior(unit_data, inventory_count)
	local entity = unit_data.entity
	unit_data.previous_inventory_count = inventory_count
	local total_count = unit_data.count + inventory_count

	if inventory_count > 0 then
		local temperature = combine_tempatures(unit_data.count, unit_data.temperature, inventory_count, entity.fluidbox[1].temperature)
		entity.fluidbox[1].temperature = temperature
		unit_data.temperature = temperature
	end

	shared.update_combinator(unit_data.combinator, {type = "fluid", name = unit_data.item, quality = "normal"}, total_count)
	shared.update_display_text(unit_data, entity, compactify(total_count))
	shared.update_power_usage(unit_data, total_count)
end

local function detect_item(unit_data)
	local fluidbox = unit_data.entity.fluidbox
	local fluid = fluidbox[1]
	if fluid then
		fluidbox.set_filter(1, {name = fluid.name, force = true})
		render_fluid_animation(fluid.name, unit_data.entity)
		unit_data.item = fluid.name
		unit_data.temperature = fluid.temperature
		return true
	end
	return false
end

local function update_unit(unit_data, unit_number, force)
	local entity = unit_data.entity

	if validity_check(unit_number, unit_data, force) then return end

	local changed = false

	if unit_data.item == nil then changed = detect_item(unit_data) end
	local item = unit_data.item
	if item == nil then return end
	local comfortable = unit_data.comfortable

	local inventory_count = entity.get_fluid_count(item)
	if inventory_count > comfortable then
		local amount_removed = entity.remove_fluid {name = item, amount = inventory_count - comfortable}
		unit_data.temperature = combine_tempatures(unit_data.count, unit_data.temperature, amount_removed, entity.fluidbox[1].temperature)
		unit_data.count = unit_data.count + amount_removed
		inventory_count = inventory_count - amount_removed
		changed = true
	elseif inventory_count < comfortable then
		if unit_data.previous_inventory_count ~= inventory_count then
			changed = true
		end
		local to_add = comfortable - inventory_count
		if unit_data.count < to_add then
			to_add = unit_data.count
		end
		if to_add > 0.001 then
			local amount_added = entity.insert_fluid {name = item, amount = to_add, temperature = unit_data.temperature}
			unit_data.count = unit_data.count - amount_added
			inventory_count = inventory_count + amount_added
		end
	end

	if force or changed then update_unit_exterior(unit_data, inventory_count) end
end

script.on_nth_tick(update_rate, function(event)
	local smooth_ups = event.tick % update_slots

	for unit_number, unit_data in pairs(storage.units) do
		if unit_data.lag_id == smooth_ups then
			update_unit(unit_data, unit_number)
		end
	end
end)

local function on_created(event)
	local entity = event.entity
	if entity.name ~= "fluid-memory-unit" then return end
	local position = entity.position
	local surface = entity.surface
	local force = entity.force

	local combinator = surface.create_entity {
		name = "fluid-memory-unit-combinator",
		position = {position.x, position.y - 1.25},
		force = force,
		quality = entity.quality
	}
	combinator.operable = false
	combinator.destructible = false

	local powersource = surface.create_entity {
		name = "fluid-memory-unit-powersource",
		position = position,
		force = force,
		quality = entity.quality
	}
	powersource.destructible = false

	local unit_data = {
		entity = entity,
		comfortable = 0.5 * entity.fluidbox.get_capacity(1),
		powersource = powersource,
		combinator = combinator,
		count = 0,
		lag_id = math.random(0, update_slots - 1)
	}
	storage.units[entity.unit_number] = unit_data

	local inventory = event.consumed_items
	local tags = event.tags or (inventory and not inventory.is_empty() and inventory[1].valid_for_read and inventory[1].is_item_with_tags and inventory[1].tags) or nil
	if tags and tags.name then
		unit_data.count = tags.count
		unit_data.temperature = tags.temperature
		unit_data.item = tags.name
		entity.fluidbox.set_filter(1, {name = tags.name, force = true})
		render_fluid_animation(tags.name, entity)
		update_unit(unit_data, entity.unit_number, true)
	else
		shared.update_power_usage(unit_data, 0)
	end
end

script.on_event(defines.events.on_built_entity, on_created)
script.on_event(defines.events.on_robot_built_entity, on_created)
script.on_event(defines.events.script_raised_built, on_created)
script.on_event(defines.events.script_raised_revive, on_created)
script.on_event(defines.events.on_space_platform_built_entity, on_created)

script.on_event(defines.events.on_entity_cloned, function(event)
	local entity = event.source
	if entity.name ~= "fluid-memory-unit" then return end
	local destination = event.destination

	local unit_data = storage.units[entity.unit_number]
	local position = destination.position
	local surface = destination.surface

	local powersource, combinator = unit_data.powersource, unit_data.combinator

	if powersource.valid then
		powersource = powersource.clone {position = position, surface = surface}
	else
		powersource = surface.create_entity {
			name = "memory-unit-powersource",
			position = position,
			force = entity.force_index
		}
		powersource.destructible = false
	end

	if combinator.valid then
		combinator = combinator.clone {position = {position.x, position.y - 1.25}, surface = surface}
	else
		combinator = surface.create_entity {
			name = "fluid-memory-unit-combinator",
			position = {position.x, position.y - 1.25},
			force = entity.force_index
		}
		combinator.destructible = false
		combinator.operable = false
	end

	local item = unit_data.item
	storage.units[destination.unit_number] = {
		powersource = powersource,
		combinator = combinator,
		item = item,
		count = unit_data.count,
		entity = destination,
		temperature = unit_data.temperature,
		comfortable = unit_data.comfortable,
		lag_id = math.random(0, update_slots - 1)
	}

	if item then
		render_fluid_animation(item, destination)
		destination.fluidbox.set_filter(1, {name = item, force = true})
		update_unit(storage.units[destination.unit_number], destination.unit_number, true)
	end
end)

local function on_destroyed(event)
	local entity = event.entity
	if entity.name ~= "fluid-memory-unit" then return end

	local unit_data = storage.units[entity.unit_number]
	storage.units[entity.unit_number] = nil
	unit_data.powersource.destroy()
	unit_data.combinator.destroy()

	local item = unit_data.item
	local count = unit_data.count
	local buffer = event.buffer

	if buffer and item and count ~= 0 then
		buffer.clear()
		local temperature = unit_data.temperature
		buffer.insert {
			name = "fluid-memory-unit-with-tags",
			count = 1,
			health = entity.health / entity.max_health,
			custom_description = {
				"item-description.fluid-memory-unit-with-tags",
				compactify(count),
				item,
				string.format("%.2f", temperature)
			},
			tags = {name = item, count = count, temperature = temperature},
			quality = entity.quality
		}
	end
end

script.on_event(defines.events.on_player_mined_entity, on_destroyed)
script.on_event(defines.events.on_robot_mined_entity, on_destroyed)
script.on_event(defines.events.on_entity_died, on_destroyed)
script.on_event(defines.events.script_raised_destroy, on_destroyed)
script.on_event(defines.events.on_space_platform_mined_entity, on_destroyed)

local function pre_mined(event)
	local entity = event.entity
	if entity.name ~= "fluid-memory-unit" then return end

	local unit_data = storage.units[entity.unit_number]
	local item = unit_data.item

	if item then
		local in_inventory = entity.get_fluid_count(item)

		if in_inventory > 0 then
			local temperature = entity.fluidbox[1].temperature
			local new_count = unit_data.count + entity.remove_fluid {name = item, amount = in_inventory}
			unit_data.temperature = combine_tempatures(unit_data.count, unit_data.temperature, in_inventory, temperature)
			unit_data.count = new_count
		end
	end
end

script.on_event(defines.events.on_pre_player_mined_item, pre_mined)
script.on_event(defines.events.on_robot_pre_mined, pre_mined)
script.on_event(defines.events.on_marked_for_deconstruction, pre_mined)
script.on_event(defines.events.on_space_platform_pre_mined, pre_mined)