Добавлены все обновления от сообщества, вплоть до #148

mining-patch-planner/mpp/render_util.lua

@@ -0,0 +1,788 @@
+local mpp_util = require("mpp.mpp_util")
+local color = require("mpp.color")
+
+local floor, ceil = math.floor, math.ceil
+local min, max = math.min, math.max
+local EAST, NORTH, SOUTH, WEST = mpp_util.directions()
+
+local render_util = {}
+
+---@class RendererParams
+---@field origin MapPosition?
+---@field target MapPosition?
+---@field x number?
+---@field y number?
+---@field w number?
+---@field h number?
+---@field r number?
+---@field color Color?
+---@field width number?
+---@field c Color?
+---@field left_top MapPosition?
+---@field right_bottom MapPosition?
+
+---this went off the rails
+---@param event EventData.on_player_reverse_selected_area
+---@return MppRendering
+function render_util.renderer(event)
+
+	---@param t RendererParams
+	local function parametrizer(t, overlay)
+
+		for k, v in pairs(overlay or {}) do t[k] = v end
+		if t.x and t.y then t.origin = {t.x, t.y} end
+		local target = t.origin or t.left_top --[[@as MapPosition]]
+		local left_top, right_bottom = t.left_top or t.origin or target, t.right_bottom or t.origin
+
+		if t.origin and t.w or t.h then
+			t.w, t.h = t.w or t.h, t.h or t.w
+			right_bottom = {(target[1] or target.x) + t.w, (target[2] or target.y) + t.h}
+		elseif t.r then
+			local r = t.r
+			local ox, oy = target[1] or target.x, target[2] or target.y
+			left_top = {ox-r, oy-r}
+			right_bottom = {ox+r, oy+r}
+		end
+
+		local new = {
+			surface = event.surface,
+			players = {event.player_index},
+			filled = false,
+			radius = t.r or 1,
+			color = t.c or t.color or {1, 1, 1},
+			left_top = left_top,
+			right_bottom = right_bottom,
+			target = target, -- circles
+			from = left_top,
+			to = right_bottom, -- lines
+			width = 1,
+		}
+		for k, v in pairs(t) do new[k]=v end
+		for _, v in ipairs{"x", "y", "h", "w", "r", "origin"} do new[v]=nil end
+		return new
+	end
+
+	local meta_renderer_meta = {}
+	meta_renderer_meta.__index = function(self, k)
+		return function(t, t2)
+			return {
+				rendering[k](
+					parametrizer(t, t2)
+				)
+			}
+	end end
+	local rendering = setmetatable({}, meta_renderer_meta)
+
+	---@class MppRendering
+	local rendering_extension = {}
+
+	---Draws an x between left_top and right_bottom
+	---@param params RendererParams
+	function rendering_extension.draw_cross(params)
+		rendering.draw_line(params)
+		rendering.draw_line({
+			width = params.width,
+			color = params.color,
+			left_top={
+				params.right_bottom[1],
+				params.left_top[2]
+			},
+			right_bottom={
+				params.left_top[1],
+				params.right_bottom[2],
+			}
+		})
+	end
+
+	function rendering_extension.draw_rectangle_dashed(params)
+		rendering.draw_line(params, {
+			from={params.left_top[1], params.left_top[2]},
+			to={params.right_bottom[1], params.left_top[2]},
+			dash_offset = 0.0,
+		})
+		rendering.draw_line(params, {
+			from={params.left_top[1], params.right_bottom[2]},
+			to={params.right_bottom[1], params.right_bottom[2]},
+			dash_offset = 0.5,
+		})
+		rendering.draw_line(params, {
+			from={params.right_bottom[1], params.left_top[2]},
+			to={params.right_bottom[1], params.right_bottom[2]},
+			dash_offset = 0.0,
+		})
+		rendering.draw_line(params, {
+			from={params.left_top[1], params.left_top[2]},
+			to={params.left_top[1], params.right_bottom[2]},
+			dash_offset = 0.5,
+		})
+	end
+
+	local meta = {}
+	function meta:__index(k)
+		return function(t, t2)
+			if rendering_extension[k] then
+				rendering_extension[k](parametrizer(t, t2))
+			else
+				rendering[k](parametrizer(t, t2))
+			end
+		end
+	end
+
+	return setmetatable({}, meta)
+end
+
+function render_util.draw_clear_rendering(player_data, event)
+	rendering.clear("mining-patch-planner")
+end
+
+---Draws the properties of a mining drill
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_drill_struct(player_data, event)
+
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+	local x, y = fx1 + 0.5, fy1 + 0.5
+	local fx2, fy2 = event.area.right_bottom.x, event.area.right_bottom.y
+	fx2, fy2 = ceil(fx2), ceil(fy2)
+
+	--renderer.draw_cross{x=fx1, y=fy1, w=fx2-fx1, h=fy2-fy1}
+	--renderer.draw_cross{x=fx1, y=fy1, w=2}
+
+	local drill = mpp_util.miner_struct(player_data.choices.miner_choice)
+
+	renderer.draw_circle{
+		x = fx1 + drill.drop_pos.x,
+		y = fy1 + drill.drop_pos.y,
+		c = {0, 1, 0},
+		r = 0.2,
+	}
+
+	-- drop pos
+	renderer.draw_cross{
+		x = fx1 + 0.5 + drill.out_x,
+		y = fy1 + 0.5 + drill.out_y,
+		r = 0.3,
+	}
+
+	for _, pos in pairs(drill.output_rotated) do
+		renderer.draw_cross{
+			x = fx1 + 0.5 + pos[1],
+			y = fy1 + 0.5 + pos[2],
+			r = 0.15,
+			width = 3,
+			c={0, 0, 0, .5},
+		}
+	end
+
+	renderer.draw_line{
+		from={x + drill.x, y},
+		to={x + drill.x, y + 2},
+		width = 2, color={0.5, 0.5, 0.5}
+	}
+	renderer.draw_line{
+		from={x + drill.x, y},
+		to={x + drill.x-.5, y + .65},
+		width = 2, color={0.5, 0.5, 0.5}
+	}
+	renderer.draw_line{
+		from={x + drill.x, y},
+		to={x + drill.x+.5, y + .65},
+		width = 2, color={0.5, 0.5, 0.5}
+	}
+
+
+	-- drill origin
+	renderer.draw_circle{
+		x = fx1 + 0.5,
+		y = fy1 + 0.5,
+		width = 2,
+		r = 0.4,
+	}
+
+	renderer.draw_text{
+		target={fx1 + .5, fy1 + .5},
+		text = "(0, 0)",
+		alignment = "center",
+		vertical_alignment="middle",
+		scale = 0.6,
+	}
+
+	-- negative extent - cyan
+	renderer.draw_cross{
+		x = fx1 +.5 + drill.extent_negative,
+		y = fy1 +.5 + drill.extent_negative,
+		r = 0.25,
+		c = {0, 0.8, 0.8},
+	}
+
+	-- positive extent - purple
+	renderer.draw_cross{
+		x = fx1 +.5 + drill.extent_positive,
+		y = fy1 +.5 + drill.extent_positive,
+		r = 0.25,
+		c = {1, 0, 1},
+	}
+
+	renderer.draw_rectangle{
+		x=fx1,
+		y=fy1,
+		w=drill.size,
+		h=drill.size,
+		width=3,
+		gap_length=0.5,
+		dash_length=0.5,
+	}
+
+	renderer.draw_rectangle_dashed{
+		x=fx1 + drill.extent_negative,
+		y=fy1 + drill.extent_negative,
+		w=drill.area,
+		h=drill.area,
+		c={0.5, 0.5, 0.5},
+		width=5,
+		gap_length=0.5,
+		dash_length=0.5,
+	}
+
+	if drill.supports_fluids then
+		-- pipe connections
+		renderer.draw_line{
+			width=4, color = {0, .7, 1},
+			from={fx1-.3, y+drill.pipe_left-.5},
+			to={fx1-.3, y+drill.pipe_left+.5},
+		}
+		renderer.draw_line{
+			width=4, color = {.7, .7, 0},
+			from={fx1+drill.size+.3, y+drill.pipe_left-.5},
+			to={fx1+drill.size+.3, y+drill.pipe_left+.5},
+		}
+	end
+
+	renderer.draw_text{
+		target={fx1 + drill.extent_negative, fy1 + drill.extent_negative-1.5},
+		text = string.format("skip_outer: %s", drill.skip_outer),
+		alignment = "left",
+		vertical_alignment="middle",
+	}
+
+	renderer.draw_circle{x = fx1, y = fy1, r = 0.1}
+	--renderer.draw_circle{ x = fx2, y = fy2, r = 0.15, color={1, 0, 0} }
+end
+
+---Preview the pole coverage
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_pole_layout(player_data, event)
+	rendering.clear("mining-patch-planner")
+
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	--renderer.draw_cross{x=fx1, y=fy1, w=fx2-fx1, h=fy2-fy1}
+	--renderer.draw_cross{x=fx1, y=fy1, w=2}
+
+	local drill = mpp_util.miner_struct(player_data.choices.miner_choice)
+	local pole = mpp_util.pole_struct(player_data.choices.pole_choice)
+
+	local function draw_lane(x, y, count)
+		for i = 0, count-1 do
+			renderer.draw_rectangle{
+				x = x + drill.size * i + 0.15 , y = y+.15,
+				w = drill.size-.3, h=1-.3,
+				color = i % 2 == 0 and {143/255, 86/255, 59/255} or {223/255, 113/255, 38/255},
+				width=2,
+			}
+		end
+
+		---@diagnostic disable-next-line: param-type-mismatch
+		local coverage = mpp_util.calculate_pole_coverage(player_data.choices, count, 1)
+
+		renderer.draw_circle{
+			x=x+.5, y=y-0.5, radius = .25, color={0.7, 0.7, 0.7},
+		}
+		for i = coverage.pole_start, coverage.full_miner_width, coverage.pole_step do
+			renderer.draw_circle{
+				x = x + i + .5,
+				y = y - .5,
+				radius = 0.3, width=2,
+				color = {0, 1, 1},
+			}
+			renderer.draw_line{
+				x = x + i +.5 - pole.supply_width / 2+.2,
+				y = y - .2,
+				h = 0,
+				w = pole.supply_width-.4,
+				color = {0, 1, 1},
+				width = 2,
+			}
+			renderer.draw_line{
+				x = x + i +.5 - pole.supply_width / 2 + .2,
+				y = y - .7,
+				h = .5,
+				w = 0,
+				color = {0, 1, 1},
+				width = 2,
+			}
+			renderer.draw_line{
+				x = x + i +.5 + pole.supply_width / 2 - .2,
+				y = y - .7,
+				h = .5,
+				w = 0,
+				color = {0, 1, 1},
+				width = 2,
+			}
+		end
+	end
+
+	for i = 1, 10 do
+		draw_lane(fx1, fy1+(i-1)*3, i)
+	end
+
+end
+
+---Preview the pole coverage
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_pole_layout_compact(player_data, event)
+	rendering.clear("mining-patch-planner")
+
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	--renderer.draw_cross{x=fx1, y=fy1, w=fx2-fx1, h=fy2-fy1}
+	--renderer.draw_cross{x=fx1, y=fy1, w=2}
+
+	local drill = mpp_util.miner_struct(player_data.choices.miner_choice)
+	local pole = mpp_util.pole_struct(player_data.choices.pole_choice)
+
+	local function draw_lane(x, y, count)
+		for i = 0, count-1 do
+			renderer.draw_rectangle{
+				x = x + drill.size * i + 0.15 , y = y+.15,
+				w = drill.size-.3, h=1-.3,
+				color = i % 2 == 0 and {143/255, 86/255, 59/255} or {223/255, 113/255, 38/255},
+				width=2,
+			}
+		end
+
+		---@diagnostic disable-next-line: param-type-mismatch
+		local coverage = mpp_util.calculate_pole_spacing(player_data.choices, count, 1)
+
+		renderer.draw_circle{
+			x=x+.5, y=y-0.5, radius = .25, color={0.7, 0.7, 0.7},
+		}
+		for i = coverage.pole_start, coverage.full_miner_width, coverage.pole_step do
+			renderer.draw_circle{
+				x = x + i + .5,
+				y = y - .5,
+				radius = 0.3, width=2,
+				color = {0, 1, 1},
+			}
+			renderer.draw_line{
+				x = x + i +.5 - pole.supply_width / 2+.2,
+				y = y - .2,
+				h = 0,
+				w = pole.supply_width-.4,
+				color = {0, 1, 1},
+				width = 2,
+			}
+			renderer.draw_line{
+				x = x + i +.5 - pole.supply_width / 2 + .2,
+				y = y - .7,
+				h = .5,
+				w = 0,
+				color = {0, 1, 1},
+				width = 2,
+			}
+			renderer.draw_line{
+				x = x + i +.5 + pole.supply_width / 2 - .2,
+				y = y - .7,
+				h = .5,
+				w = 0,
+				color = {0, 1, 1},
+				width = 2,
+			}
+		end
+	end
+
+	for i = 1, 10 do
+		draw_lane(fx1, fy1+(i-1)*3, i)
+	end
+
+end
+
+---Displays the labels of built things on the grid
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_built_things(player_data, event)
+	rendering.clear("mining-patch-planner")
+
+	local renderer = render_util.renderer(event)
+
+	local state = player_data.last_state
+
+	if not state then return end
+
+	local C = state.coords
+	local G = state.grid
+
+	for _, row in pairs(G) do
+		for _, tile in pairs(row) do
+			---@cast tile GridTile
+			local thing = tile.built_on
+			if thing then
+				-- renderer.draw_circle{
+				-- 	x = C.gx + tile.x, y = C.gy + tile.y,
+				-- 	w = 1,
+				-- 	color = {0, 0.5, 0, 0.1},
+				-- 	r = 0.5,
+				-- }
+				renderer.draw_rectangle{
+					x = C.ix1 + tile.x -.9, y = C.iy1 + tile.y -.9,
+					w = .8,
+					color = {0, 0.2, 0, 0.1},
+				}
+				renderer.draw_text{
+					x = C.gx + tile.x, y = C.gy + tile.y - .3,
+					alignment = "center",
+					vertical_alignment = "top",
+					--vertical_alignment = tile.x % 2 == 1 and "top" or "bottom",
+					text = thing,
+					scale = 0.6,
+				}
+			end
+		end
+	end
+
+end
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_drill_convolution(player_data, event)
+	rendering.clear("mining-patch-planner")
+
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	local state = player_data.last_state
+	if not state then return end
+
+	local C = state.coords
+	local grid = state.grid
+
+	for _, row in pairs(grid) do
+		for _, tile in pairs(row) do
+			---@cast tile GridTile
+			--local c1, c2 = tile.neighbor_counts[m_size], tile.neighbor_counts[m_area]
+			local c1, c2 = tile.neighbors_inner, tile.neighbors_outer
+			if c1 == 0 and c2 == 0 then goto continue end
+
+			rendering.draw_circle{
+				surface = state.surface, filled=false, color = {0.3, 0.3, 1},
+				width=1, radius = 0.5,
+				target={C.gx + tile.x, C.gy + tile.y},
+			}
+			local stagger = (.5 - (tile.x % 2)) * .25
+			local col = c1 == 0 and {0.3, 0.3, 0.3} or {0.6, 0.6, 0.6}
+			rendering.draw_text{
+				surface = state.surface, filled = false, color = col,
+				target={C.gx + tile.x, C.gy + tile.y + stagger},
+				text = string.format("%i,%i", c1, c2),
+				alignment = "center",
+				vertical_alignment="middle",
+			}
+
+			::continue::
+		end
+	end
+
+end
+
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_power_grid(player_data, event)
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	local state = player_data.last_state
+	if not state then return end
+	---@cast state SimpleState
+
+	local C = state.coords
+	local grid = state.grid
+
+	local connectivity = state.power_connectivity
+	if not connectivity then
+		game.print("No connectivity exists")
+		return
+	end
+	local rendered = {}
+
+	for set_id, set in pairs(connectivity) do
+		local set_color = color.hue_sequence(set_id)
+		if set_id == 0 then set_color = {1, 1, 1} end
+		for pole, _ in pairs(set) do
+			---@cast pole GridPole
+			-- if rendered[pole] then goto continue end
+			-- rendered[pole] = true
+			local pole_color = set_color
+			-- if not pole.backtracked and not pole.has_consumers then
+			-- 	pole_color = {0, 0, 0}
+			-- end
+
+			renderer.draw_circle{
+				surface = state.surface,
+				filled = not pole.backtracked,
+				color = pole_color,
+				width = 5,
+				target = {C.gx + pole.grid_x, C.gy + pole.grid_y},
+				radius = 0.65,
+			}
+			renderer.draw_text{
+				surface = state.surface,
+				target={C.gx + pole.grid_x, C.gy + pole.grid_y},
+				text = set_id,
+				alignment = "center",
+				vertical_alignment="middle",
+				scale = 2,
+			}
+			renderer.draw_text{
+				surface = state.surface,
+				target={C.gx + pole.grid_x, C.gy + pole.grid_y-1.25},
+				text = ("%i,%i"):format(pole.ix, pole.iy),
+				alignment = "center",
+				vertical_alignment="middle",
+				scale = 2,
+			}
+			::continue::
+		end
+	end --]]
+
+end
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_centricity(player_data, event)
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	local state = player_data.last_state
+	if not state then return end
+
+	local C = state.coords
+	local grid = state.grid
+
+	
+
+end
+
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_blueprint_data(player_data, event)
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+	local x, y = fx1 + 0.5, fy1 + 0.5
+
+	local id = player_data.choices.blueprint_choice and player_data.choices.blueprint_choice.item_number
+	if not id then return end
+	local bp = player_data.blueprints.cache[id]
+	if not bp then return end
+
+	renderer.draw_line{x = fx1, y = fy1-1, w = 0, h = 2, width = 7, color={0, 0, 0}}
+	renderer.draw_line{x = fx1-1, y = fy1, w = 2, h = 0, width = 7, color={0, 0, 0}}
+
+	renderer.draw_rectangle{
+		x = fx1,
+		y = fy1,
+		w = bp.w,
+		h = bp.h,
+	}
+
+	for _, ent in pairs(bp.entities) do
+		local struct = mpp_util.entity_struct(ent.name)
+		local clr = {1, 1, 1}
+		if ent.capstone_x and ent.capstone_y then
+			clr = {0, 1, 1}
+		elseif ent.capstone_x then
+			clr = {0, 1, 0}
+		elseif ent.capstone_y then
+			clr = {0, 0, 1}
+		end
+		renderer.draw_circle{
+			x = fx1 + ent.position.x,
+			y = fy1 + ent.position.y,
+			r = struct.size / 2,
+			color = clr,
+		}
+	end
+
+end
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_deconstruct_preview(player_data, event)
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+
+	local state = player_data.last_state
+	if not state then return end
+
+	local c = state.coords
+	local grid = state.grid
+
+	local layout = algorithm.layouts[state.layout_choice]
+	if not layout._get_deconstruction_objects then return end
+	local objects = layout:_get_deconstruction_objects(state)
+	
+	local DIR = state.direction_choice
+
+	for _, t in pairs(objects) do
+		for _, object in ipairs(t) do
+			---@cast object GhostSpecification
+			local extent_w = object.extent_w or object.radius or 0.5
+			local extent_h = object.extent_h or extent_w
+
+			local x1, y1 = object.grid_x-extent_w, object.grid_y-extent_h
+			local x2, y2 = object.grid_x+extent_w, object.grid_y+extent_h
+
+			x1, y1 = mpp_util.revert_ex(c.gx, c.gy, DIR, x1, y1, c.tw, c.th)
+			x2, y2 = mpp_util.revert_ex(c.gx, c.gy, DIR, x2, y2, c.tw, c.th)
+
+			rendering.draw_rectangle{
+				surface=state.surface,
+				players={state.player},
+				filled=false,
+				width=3,
+				color={1, 0, 0},
+				left_top={x1+.1,y1+.1},
+				right_bottom={x2-.1,y2-.1},
+			}
+		end
+	end
+
+end
+
+---@param player_data PlayerData
+---@param event EventData.on_player_reverse_selected_area
+function render_util.draw_can_place_entity(player_data, event)
+	local renderer = render_util.renderer(event)
+
+	local fx1, fy1 = event.area.left_top.x, event.area.left_top.y
+	fx1, fy1 = floor(fx1), floor(fy1)
+	local x, y = fx1 + 0.5, fy1 + 0.5
+
+	local id = player_data.choices.blueprint_choice and player_data.choices.blueprint_choice.item_number
+	if not id then return end
+	local bp = player_data.blueprints.cache[id]
+	if not bp then return end
+
+	renderer.draw_line{x = fx1, y = fy1-1, w = 0, h = 1, width = 7, color={0.3, 0.3, 0.3}}
+	renderer.draw_line{x = fx1-1, y = fy1, w = 1, h = 0, width = 7, color={0.3, 0.3, 0.3}}
+
+	local build_check_type = defines.build_check_type
+	local can_forced = {
+		[{false, false}] = 0,
+		[{true, false}] = 1,
+		[{false, true}] = 2,
+		[{true, true}] = 3,
+	}
+
+	for check_type, i1 in pairs(build_check_type) do
+		
+		for forced_ghost, i2 in pairs(can_forced) do
+
+			local forced, ghost = forced_ghost[1], forced_ghost[2]
+
+			local nx = x + (bp.w + 3) * i1
+			local ny = y + (bp.h + 3) * i2
+
+			renderer.draw_rectangle{
+				x = nx-.5,
+				y = ny-.5,
+				w = bp.w,
+				h = bp.h,
+				color = {0.2, 0.2, .7},
+			}
+
+			-- renderer.draw_text{
+			-- 	x = nx+(bp.w-1)/2, y = ny-.5,
+			-- 	text = ("%i,%i"):format(i1, i2),
+			-- 	alignment = "center",
+			-- 	vertical_alignment="bottom",
+			-- }
+			
+			renderer.draw_text{
+				x = nx+(bp.w-1)/2, y = ny-1.5,
+				text = ("%s"):format(check_type),
+				alignment = "center",
+				vertical_alignment="bottom",
+			}
+			renderer.draw_text{
+				x = nx+(bp.w-1)/2, y = ny-1,
+				text = ("forced: %s"):format(forced),
+				alignment = "center",
+				vertical_alignment="bottom",
+			}
+			renderer.draw_text{
+				x = nx+(bp.w-1)/2, y = ny-.5,
+				text = ("ghost: %s"):format(ghost),
+				alignment = "center",
+				vertical_alignment="bottom",
+			}
+
+			for _, ent in pairs(bp.entities) do
+				local ex = nx + ent.position.x - .5
+				local ey = ny + ent.position.y - .5
+				local t = {
+					name = ent.name,
+					position = {ex, ey},
+					direction = ent.direction,
+					build_check_type = defines.build_check_type[check_type],
+					force = game.get_player(event.player_index).force,
+					forced = forced,
+				}
+				if ghost then
+					t.name, t.inner_name = "entity-ghost", t.name
+				end
+
+				local can_place = event.surface.can_place_entity(t)
+
+				renderer.draw_circle{x = ex, y = ey, r = 0.5, width = 3,
+					color = can_place and {0.1, .9, .1} or {0.9, .1, .1},
+				}
+				
+				if can_place then
+					if not ghost then
+						t.name, t.inner_name = "entity-ghost", t.name
+					end
+					event.surface.create_entity(t)
+				end
+			end
+
+		end
+
+	end
+
+end
+
+
+return render_util