diff --git a/map_gen/presets/ContraSpiral.lua b/map_gen/presets/ContraSpiral.lua
index 53d71044..37252691 100644
--- a/map_gen/presets/ContraSpiral.lua
+++ b/map_gen/presets/ContraSpiral.lua
@@ -5,10 +5,12 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.CSrMap"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local b = require "map_gen.shared.builders"
 
-local map = single_pattern_builder(map, pic.width, pic.height)
+local pic = require "map_gen.data.presets.CSrMap"
+local pic = b.decompress(pic)
+local map = b.picture(pic)
+
+local map = b.single_pattern(map, pic.width, pic.height)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/GoT.lua b/map_gen/presets/GoT.lua
index bc679d7f..ca391b41 100644
--- a/map_gen/presets/GoT.lua
+++ b/map_gen/presets/GoT.lua
@@ -5,10 +5,12 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.GoT"
-local pic = decompress(pic)
+local b = require "map_gen.shared.builders"
 
-local shape = picture_builder(pic)
-local shape = translate(shape, 752, -408)
+local pic = require "map_gen.data.presets.GoT"
+local pic = b.decompress(pic)
+
+local shape = b.picture(pic)
+local shape = b.translate(shape, 752, -408)
 
 return shape
diff --git a/map_gen/presets/UK.lua b/map_gen/presets/UK.lua
index 6dd994aa..6f956bce 100644
--- a/map_gen/presets/UK.lua
+++ b/map_gen/presets/UK.lua
@@ -5,17 +5,19 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.UK"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
 -- this changes the size of the map
-map = scale(map, 2, 2)
+map = b.scale(map, 2, 2)
 
 -- this moves the map, effectively changing the spawn point.
-map = translate(map, 0, 10)
+map = b.translate(map, 0, 10)
 
 -- this sets the tile outside the bounds of the map to deepwater, remove this and it will be void.
-map = change_tile(map, false, "deepwater")
+map = b.change_tile(map, false, "deepwater")
 
 return map
diff --git a/map_gen/presets/antfarm.lua b/map_gen/presets/antfarm.lua
index 291f32cb..ba341699 100644
--- a/map_gen/presets/antfarm.lua
+++ b/map_gen/presets/antfarm.lua
@@ -5,15 +5,17 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.antfarm"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
 local scale_factor = 12
-local shape = picture_builder(pic)
---shape = invert(shape)
+local shape = b.picture(pic)
+--shape = b.invert(shape)
 
-local map = single_pattern_builder(shape, pic.width, pic.height)
-map = translate(map, -12, 2)
-map = scale(map, scale_factor, scale_factor)
+local map = b.single_pattern(shape, pic.width, pic.height)
+map = b.translate(map, -12, 2)
+map = b.scale(map, scale_factor, scale_factor)
 
 return map
diff --git a/map_gen/presets/broken_web.lua b/map_gen/presets/broken_web.lua
index 366b975c..71d89f4d 100644
--- a/map_gen/presets/broken_web.lua
+++ b/map_gen/presets/broken_web.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.broken_web"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = invert(shape)
+local shape = b.picture(pic)
+shape = b.invert(shape)
 
-local map = single_pattern_builder(shape, pic.width, pic.height - 1)
-map = translate(map, 10, -27)
-map = scale(map, 12, 12)
+local map = b.single_pattern(shape, pic.width, pic.height - 1)
+map = b.translate(map, 10, -27)
+map = b.scale(map, 12, 12)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/connected_dots.lua b/map_gen/presets/connected_dots.lua
index 481f2cdc..16a1e1a9 100644
--- a/map_gen/presets/connected_dots.lua
+++ b/map_gen/presets/connected_dots.lua
@@ -5,6 +5,8 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local function no_resources(x, y, world, tile)
     for _, e in ipairs(world.surface.find_entities_filtered({type = "resource", area = {{world.x, world.y}, {world.x + 1, world.y + 1}}})) do
         e.destroy()
@@ -33,55 +35,55 @@ local function no_enemies(x, y, world, tile)
     return tile
 end
 
-local small_dot = circle_builder(96)
-local mediumn_dot = circle_builder(128)
-local big_dot = circle_builder(160)
+local small_dot = b.circle(96)
+local mediumn_dot = b.circle(128)
+local big_dot = b.circle(160)
 
-local arms = path_builder(48)
-arms = change_tile(arms, true, "water")
+local arms = b.path(48)
+arms = b.change_tile(arms, true, "water")
 
-local arms2 = rotate(arms, degrees(45))
+local arms2 = b.rotate(arms, degrees(45))
 
-local shape = compound_or{translate(arms2, 480, 0), translate(arms2, -480, 0), mediumn_dot, arms}
-shape = apply_effect(shape, no_resources)
---shape = apply_effect(shape, less_resources)
-shape = apply_effect(shape, no_enemies)
+local shape = b.any{b.translate(arms2, 480, 0), b.translate(arms2, -480, 0), mediumn_dot, arms}
+shape = b.apply_effect(shape, no_resources)
+--shape = b.apply_effect(shape, less_resources)
+shape = b.apply_effect(shape, no_enemies)
 
 
-local shape2 = compound_and{big_dot, invert(small_dot)}
-shape2 = choose(big_dot, shape2, compound_or{arms, rotate(arms, degrees(45))})
---shape2 = apply_effect(shape2, less_resources)
-local start = apply_effect(mediumn_dot, no_resources)
+local shape2 = b.all{big_dot, b.invert(small_dot)}
+shape2 = b.choose(big_dot, shape2, b.any{arms, b.rotate(arms, degrees(45))})
+--shape2 = b.apply_effect(shape2, less_resources)
+local start = b.apply_effect(mediumn_dot, no_resources)
 
-local iron = circle_builder(16)
-iron = translate(iron, 0, -96)
---iron = rotate(iron, degrees(0))
-iron = resource_module_builder(iron, "iron-ore", function(x, y) return 700 end)
+local iron = b.circle(16)
+iron = b.translate(iron, 0, -96)
+--iron = b.rotate(iron, degrees(0))
+iron = b.resource(iron, "iron-ore", function(x, y) return 700 end)
 
-local copper = circle_builder(12)
-copper = translate(copper, 0, -96)
-copper = rotate(copper, degrees(72))
-copper = resource_module_builder(copper, "copper-ore", function(x, y) return 600 end)
+local copper = b.circle(12)
+copper = b.translate(copper, 0, -96)
+copper = b.rotate(copper, degrees(72))
+copper = b.resource(copper, "copper-ore", function(x, y) return 600 end)
 
-local stone = circle_builder(8)
-stone = translate(stone, 0, -96)
-stone = rotate(stone, degrees(144))
-stone = resource_module_builder(stone, "stone", function(x, y) return 1500 end)
+local stone = b.circle(8)
+stone = b.translate(stone, 0, -96)
+stone = b.rotate(stone, degrees(144))
+stone = b.resource(stone, "stone", function(x, y) return 1500 end)
 
-local coal = circle_builder(10)
-coal = translate(coal, 0, -96)
-coal = rotate(coal, degrees(216))
-coal = resource_module_builder(coal, "coal", function(x, y) return 850 end)
+local coal = b.circle(10)
+coal = b.translate(coal, 0, -96)
+coal = b.rotate(coal, degrees(216))
+coal = b.resource(coal, "coal", function(x, y) return 850 end)
 
-local oil = circle_builder(5)
-oil = throttle_xy(oil, 1, 3, 1, 3)
-oil = translate(oil, 0, -96)
-oil = rotate(oil, degrees(288))
-oil = resource_module_builder(oil, "crude-oil", function(x, y) return 60000 end)
+local oil = b.circle(5)
+oil = b.throttle_xy(oil, 1, 3, 1, 3)
+oil = b.translate(oil, 0, -96)
+oil = b.rotate(oil, degrees(288))
+oil = b.resource(oil, "crude-oil", function(x, y) return 60000 end)
 
-start = builder_with_resource(mediumn_dot, compound_or{iron, copper, stone, coal, oil})
+start = b.apply_entity(mediumn_dot, b.any{iron, copper, stone, coal, oil})
 
-start = apply_effect(start, no_resources)
+start = b.apply_effect(start, no_resources)
 
 local pattern =
     {
@@ -89,9 +91,9 @@ local pattern =
         {shape2, shape}
     }
 
-local map = grid_pattern_builder(pattern, 2, 2, 480, 480)
-map = choose(mediumn_dot, start, map)
+local map = b.grid_pattern(pattern, 2, 2, 480, 480)
+map = b.choose(mediumn_dot, start, map)
 
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
 return map
diff --git a/map_gen/presets/cookies.lua b/map_gen/presets/cookies.lua
index df2e2ed4..d89f9206 100644
--- a/map_gen/presets/cookies.lua
+++ b/map_gen/presets/cookies.lua
@@ -5,6 +5,8 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local seed1 = 666
 local seed2 = 999
 
@@ -16,20 +18,20 @@ local Random = require "map_gen.shared.random"
 local random = Random.new(seed1, seed2)
 
 local pic = require "map_gen.data.presets.cookie"
-local pic = decompress(pic)
-local cookie1 = picture_builder(pic)
-local cookie = scale(cookie1, 0.1, 0.1)
+local pic = b.decompress(pic)
+local cookie1 = b.picture(pic)
+local cookie = b.scale(cookie1, 0.1, 0.1)
 
-local ore_shape = circle_builder(1.5)
+local ore_shape = b.circle(1.5)
 
 local ores = {
-    {resource_module_builder(ore_shape, "iron-ore", value), 24},
-    {resource_module_builder(ore_shape, "copper-ore", value), 12},
-    {resource_module_builder(ore_shape, "stone", value), 4},
-    {resource_module_builder(ore_shape, "coal", value), 8},
-    {resource_module_builder(ore_shape, "uranium-ore", value), 1},
-    {resource_module_builder(circle_builder(1), "crude-oil", manhattan_ore_value(250000, 250)), 3},
---{empty_builder, 10}
+    {b.resource(ore_shape, "iron-ore", value), 24},
+    {b.resource(ore_shape, "copper-ore", value), 12},
+    {b.resource(ore_shape, "stone", value), 4},
+    {b.resource(ore_shape, "coal", value), 8},
+    {b.resource(ore_shape, "uranium-ore", value), 1},
+    {b.resource(b.circle(1), "crude-oil", b.manhattan_value(250000, 250)), 3},
+--{b.empty_shape, 10}
 }
 
 local total_weights = {}
@@ -48,7 +50,7 @@ local function makeChips()
     end
     
     local shape = ores[index][1]
-    if shape == empty_builder then
+    if shape == b.empty_shape then
         return nil
     end
     
@@ -57,7 +59,7 @@ local function makeChips()
         local x_offset = random:next_int(-20, 20)
         local y_offset = random:next_int(-20, 20)
         
-        local shape2 = translate(shape, x_offset, y_offset)
+        local shape2 = b.translate(shape, x_offset, y_offset)
         
         table.insert(chips, shape2)
     end
@@ -77,7 +79,7 @@ for c = 1, p_cols do
         
         local shape
         if chips then
-            shape = builder_with_resource(cookie, compound_or(chips))
+            shape = b.apply_entity(cookie, b.any(chips))
         else
             shape = cookie
         end
@@ -87,16 +89,16 @@ for c = 1, p_cols do
         local x_offset = random:next_int(-8, 8)
         local y_offset = random:next_int(-8, 8)
         
-        shape = rotate(shape, degrees(angle))
-        shape = scale(shape, s, s * 0.75)
-        shape = translate(shape, x_offset, y_offset)
+        shape = b.rotate(shape, degrees(angle))
+        shape = b.scale(shape, s, s * 0.75)
+        shape = b.translate(shape, x_offset, y_offset)
         
         table.insert(row, shape)
     end
 end
 
-local cookies = grid_pattern_full_overlap_builder(pattern, p_cols, p_rows, 64 * 1.25, 41 * 1.25 * 0.5)
-cookies = flip_y(cookies)
+local cookies = b.grid_pattern_full_overlap(pattern, p_cols, p_rows, 64 * 1.25, 41 * 1.25 * 0.5)
+cookies = b.flip_y(cookies)
 
 local tablecloth = {
     height = 2,
@@ -106,11 +108,11 @@ local tablecloth = {
         {"water", "deepwater", }
     }
 }
-local tablecloth = picture_builder(tablecloth)
-tablecloth = single_pattern_builder(tablecloth, 2, 2)
-tablecloth = scale(tablecloth, 42, 42)
-tablecloth = spawn_fish(tablecloth, 0.005)
+local tablecloth = b.picture(tablecloth)
+tablecloth = b.single_pattern(tablecloth, 2, 2)
+tablecloth = b.scale(tablecloth, 42, 42)
+tablecloth = b.fish(tablecloth, 0.005)
 
-map = shape_or_else(cookies, tablecloth)
+map = b.if_else(cookies, tablecloth)
 
 return map
diff --git a/map_gen/presets/creation_of_adam.lua b/map_gen/presets/creation_of_adam.lua
index 51c9f7a1..0797882c 100644
--- a/map_gen/presets/creation_of_adam.lua
+++ b/map_gen/presets/creation_of_adam.lua
@@ -5,22 +5,24 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 require "map_gen.shared.generate_not_threaded"
 --require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.creation_of_adam"
-local pic = decompress(pic)
+local pic = b.decompress(pic)
 
 local scale_factor = 3
-local shape = picture_builder(pic)
-shape = scale(shape, scale_factor, scale_factor)
+local shape = b.picture(pic)
+shape = b.scale(shape, scale_factor, scale_factor)
 
 local pattern =
 {
-    { shape , flip_x(shape) },
-    { flip_y(shape), flip_xy(shape) }
+    { shape , b.flip_x(shape) },
+    { b.flip_y(shape), b.flip_xy(shape) }
 }
 
-local map = grid_pattern_builder(pattern, 2, 2, pic.width * scale_factor, pic.height * scale_factor)
-map = translate(map, 128 * scale_factor, 26 * scale_factor)
+local map = b.grid_pattern(pattern, 2, 2, pic.width * scale_factor, pic.height * scale_factor)
+map = b.translate(map, 128 * scale_factor, 26 * scale_factor)
 
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/crosses.lua b/map_gen/presets/crosses.lua
index 15090e4e..f4a1816a 100644
--- a/map_gen/presets/crosses.lua
+++ b/map_gen/presets/crosses.lua
@@ -5,12 +5,14 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.crosses"
-pic = decompress(pic)
+local b = require "map_gen.shared.builders"
 
-local shape = picture_builder(pic)
-local map = single_pattern_builder(shape, pic.width, pic.height)
-map = translate(map, 10, -4)
-map = scale(map, 12, 12)
+local pic = require "map_gen.data.presets.crosses"
+pic = b.decompress(pic)
+
+local shape = b.picture(pic)
+local map = b.single_pattern(shape, pic.width, pic.height)
+map = b.translate(map, 10, -4)
+map = b.scale(map, 12, 12)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/crosses3.lua b/map_gen/presets/crosses3.lua
index 66b1ed7a..e124c134 100644
--- a/map_gen/presets/crosses3.lua
+++ b/map_gen/presets/crosses3.lua
@@ -5,16 +5,18 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local scale_factor = 64
 
 local pic = require "map_gen.data.presets.crosses3"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = scale(shape, scale_factor, scale_factor)
+local shape = b.picture(pic)
+shape = b.scale(shape, scale_factor, scale_factor)
 
-local map = single_pattern_builder(shape, (pic.width - 24.5 ) * scale_factor + 6, (pic.height - 21.5) * scale_factor  - 6)
-map = rotate(map, degrees(45))
-map = translate(map, 48, -176)
+local map = b.single_pattern(shape, (pic.width - 24.5 ) * scale_factor + 6, (pic.height - 21.5) * scale_factor  - 6)
+map = b.rotate(map, degrees(45))
+map = b.translate(map, 48, -176)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/dickbutt.lua b/map_gen/presets/dickbutt.lua
index d90650ac..a9389ea9 100644
--- a/map_gen/presets/dickbutt.lua
+++ b/map_gen/presets/dickbutt.lua
@@ -9,37 +9,39 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local body = rotate(oval_builder(128,256), degrees(20))
-local butt = translate(rotate(oval_builder(180, 128), degrees(30)), 130,100)
+local b = require "map_gen.shared.builders"
 
-local shaft = translate(rotate(oval_builder(32, 80), degrees(0)), 220, -80)
-local ball1 = translate(rotate(oval_builder(32,16), degrees(10)), 250,-50)
-local ball2 = translate(rotate(oval_builder(48,16), degrees(5)), 240,-40)
+local body = b.rotate(b.oval(128,256), degrees(20))
+local butt = b.translate(b.rotate(b.oval(180, 128), degrees(30)), 130,100)
 
-local leg1 = translate(rotate(rectangle_builder(16, 80), degrees(175)), 80, 280)
-local leg2 = translate(rotate(rectangle_builder(16, 80), degrees(5)), 180, 250)
-local foot1 = translate(rotate(rectangle_builder(16, 40), degrees(65)), 65, 315)
-local foot2 = translate(rotate(rectangle_builder(16, 40), degrees(65)), 170, 285)
+local shaft = b.translate(b.rotate(b.oval(32, 80), degrees(0)), 220, -80)
+local ball1 = b.translate(b.rotate(b.oval(32,16), degrees(10)), 250,-50)
+local ball2 = b.translate(b.rotate(b.oval(48,16), degrees(5)), 240,-40)
 
-local eye1 = translate(circle_builder(32),-130, -100)   
+local leg1 = b.translate(b.rotate(b.rectangle(16, 80), degrees(175)), 80, 280)
+local leg2 = b.translate(b.rotate(b.rectangle(16, 80), degrees(5)), 180, 250)
+local foot1 = b.translate(b.rotate(b.rectangle(16, 40), degrees(65)), 65, 315)
+local foot2 = b.translate(b.rotate(b.rectangle(16, 40), degrees(65)), 170, 285)
 
-local dickbutt = compound_or({body,butt,  shaft, ball1, ball2, leg1, leg2, foot1, foot2, eye1 })
-dickbutt = translate(dickbutt, -80, 0)
+local eye1 = b.translate(b.circle(32),-130, -100)   
 
-local patch = scale(dickbutt, 0.15, 0.15)
-local iron_patch = resource_module_builder(translate(scale(dickbutt, 0.15, 0.15), 20, 0), "iron-ore")
-local copper_patch = resource_module_builder(translate(scale(dickbutt, 0.115, 0.115), -125, 50), "copper-ore")
-local coal_patch = resource_module_builder(translate(scale(dickbutt, 0.1, 0.1), -135, -90), "coal")
-local stone_patch = resource_module_builder(translate(scale(dickbutt, 0.075, 0.075), 50, 150), "stone")
+local dickbutt = b.any({body,butt,  shaft, ball1, ball2, leg1, leg2, foot1, foot2, eye1 })
+dickbutt = b.translate(dickbutt, -80, 0)
 
-local patches = compound_or({ iron_patch, copper_patch, coal_patch, stone_patch })
+local patch = b.scale(dickbutt, 0.15, 0.15)
+local iron_patch = b.resource(b.translate(b.scale(dickbutt, 0.15, 0.15), 20, 0), "iron-ore")
+local copper_patch = b.resource(b.translate(b.scale(dickbutt, 0.115, 0.115), -125, 50), "copper-ore")
+local coal_patch = b.resource(b.translate(b.scale(dickbutt, 0.1, 0.1), -135, -90), "coal")
+local stone_patch = b.resource(b.translate(b.scale(dickbutt, 0.075, 0.075), 50, 150), "stone")
 
-dickbutt = builder_with_resource(dickbutt, patches)
+local patches = b.any({ iron_patch, copper_patch, coal_patch, stone_patch })
 
-local dickbutt2 = rotate(dickbutt, degrees(45))
-local dickbutt3 = rotate(dickbutt, degrees(90))
-local dickbutt4 = rotate(dickbutt, degrees(135))
-local dickbutt5 = rotate(dickbutt, degrees(180))
+dickbutt = b.apply_entity(dickbutt, patches)
+
+local dickbutt2 = b.rotate(dickbutt, degrees(45))
+local dickbutt3 = b.rotate(dickbutt, degrees(90))
+local dickbutt4 = b.rotate(dickbutt, degrees(135))
+local dickbutt5 = b.rotate(dickbutt, degrees(180))
 
 local pattern = 
 {
@@ -50,7 +52,7 @@ local pattern =
     { dickbutt5, dickbutt, dickbutt2, dickbutt3, dickbutt4 },
 }
 
-local map = grid_pattern_builder(pattern, 5, 5, 650, 650)
-map = change_tile(map, false, "water")
+local map = b.grid_pattern(pattern, 5, 5, 650, 650)
+map = b.change_tile(map, false, "water")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/dna.lua b/map_gen/presets/dna.lua
index b35dacad..461a8f72 100644
--- a/map_gen/presets/dna.lua
+++ b/map_gen/presets/dna.lua
@@ -9,9 +9,11 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local ball_r = 16
-local big_circle = circle_builder(ball_r)
-local small_circle = circle_builder(0.6 * ball_r)
+local big_circle = b.circle(ball_r)
+local small_circle = b.circle(0.6 * ball_r)
 
 local ribben = {big_circle}
 local count = 8
@@ -21,17 +23,17 @@ local offset_y = 96
 for i= 1, count do
     local x = offset_x * i
     local y = offset_y * math.sin(angle * i)
-    local c = translate(big_circle, x, y)
+    local c = b.translate(big_circle, x, y)
     table.insert(ribben, c)
 end
 for i= 0, count - 1 do
     local j = i + 0.5
     local x = offset_x * j
     local y = offset_y * math.sin(angle * j)
-    local c = translate(small_circle, x, y)
+    local c = b.translate(small_circle, x, y)
     table.insert(ribben, c)
 end
-ribben = compound_or(ribben)
+ribben = b.any(ribben)
 
 local function value(mult,base)
     return function(a, b)
@@ -39,90 +41,90 @@ local function value(mult,base)
     end
 end
 
-local oil_shape = circle_builder(0.16 * ball_r)
-oil_shape = throttle_world_xy(oil_shape, 1, 4, 1, 4)
+local oil_shape = b.circle(0.16 * ball_r)
+oil_shape = b.throttle_world_xy(oil_shape, 1, 4, 1, 4)
 
 local resources =
 {
-    resource_module_builder(circle_builder(0.2 * ball_r), "iron-ore", value(0.5, 750)),
-    resource_module_builder(circle_builder(0.2 * ball_r), "copper-ore", value(0.5, 750)),
-    resource_module_builder(circle_builder(0.15 * ball_r), "stone", value(0.2, 400)),
-    resource_module_builder(circle_builder(0.05 * ball_r), "uranium-ore", value(0.2, 600)),
-    resource_module_builder(oil_shape, "crude-oil", value(60, 160000)),
-    resource_module_builder(circle_builder(0.2 * ball_r), "coal", value(0.2, 600)),
-    resource_module_builder(circle_builder(0.2 * ball_r), "iron-ore", value(0.5, 750))
+    b.resource(b.circle(0.2 * ball_r), "iron-ore", value(0.5, 750)),
+    b.resource(b.circle(0.2 * ball_r), "copper-ore", value(0.5, 750)),
+    b.resource(b.circle(0.15 * ball_r), "stone", value(0.2, 400)),
+    b.resource(b.circle(0.05 * ball_r), "uranium-ore", value(0.2, 600)),
+    b.resource(oil_shape, "crude-oil", value(60, 160000)),
+    b.resource(b.circle(0.2 * ball_r), "coal", value(0.2, 600)),
+    b.resource(b.circle(0.2 * ball_r), "iron-ore", value(0.5, 750))
 }
 
 local lines = {}
-local lines_circle = circle_builder(0.6 * ball_r)
+local lines_circle = b.circle(0.6 * ball_r)
 for i = 1, count - 1 do
     local x = offset_x * i
     local y = offset_y * math.sin(angle * i)
 
-    local l = rectangle_builder(2, 2 * y + ball_r)
-    l = translate(l, x, 0)
+    local l = b.rectangle(2, 2 * y + ball_r)
+    l = b.translate(l, x, 0)
     
     local c = lines_circle
-    c = builder_with_resource(c, resources[i])
-    c = change_map_gen_collision_tile(c,"water-tile", "grass-1")
-    local c = translate(c, x, 0)    
+    c = b.apply_entity(c, resources[i])
+    c = b.change_map_gen_collision_tile(c,"water-tile", "grass-1")
+    local c = b.translate(c, x, 0)    
 
     table.insert(lines, c)
     table.insert(lines, l)
 end
-lines = compound_or(lines)
+lines = b.any(lines)
 
-local dna = compound_or{lines, ribben, flip_y(ribben)}
+local dna = b.any{lines, ribben, b.flip_y(ribben)}
 
 local widith = offset_x * count
-dna = translate(dna, -widith/ 2, 0)
-local map = single_x_pattern_builder(dna, widith)
+dna = b.translate(dna, -widith/ 2, 0)
+local map = b.single_x_pattern(dna, widith)
 --[[ 
-local dna1 = single_pattern_builder(dna, widith, 6 * widith)
-local dna2 = single_pattern_builder(dna, widith, 8 * widith)
-dna2 = rotate(dna2, degrees(60))
-dna2 = translate(dna2, -3 * widith, 0)
-local dna3 = single_pattern_builder(dna, widith, 8 * widith)
-local dna3 = rotate(dna3, degrees(120))
-dna3 = translate(dna3, 3 * widith, 0)
-local map = compound_or{dna1, dna2, dna3}
+local dna1 = b.single_pattern(dna, widith, 6 * widith)
+local dna2 = b.single_pattern(dna, widith, 8 * widith)
+dna2 = b.rotate(dna2, degrees(60))
+dna2 = b.translate(dna2, -3 * widith, 0)
+local dna3 = b.single_pattern(dna, widith, 8 * widith)
+local dna3 = b.rotate(dna3, degrees(120))
+dna3 = b.translate(dna3, 3 * widith, 0)
+local map = b.any{dna1, dna2, dna3}
  ]]
 
-map = translate(map, -widith/2, 0)
+map = b.translate(map, -widith/2, 0)
 
-local sea = sine_fill_builder(512, 208)
-sea = compound_or{line_x_builder(2), sea, flip_y(sea)}
-sea = change_tile(sea, true, "water")
-sea = spawn_fish(sea, 0.005)
+local sea = b.sine_fill(512, 208)
+sea = b.any{b.line_x(2), sea, b.flip_y(sea)}
+sea = b.change_tile(sea, true, "water")
+sea = b.fish(sea, 0.005)
 
-map = compound_or{map, sea}
+map = b.any{map, sea}
 
-map = rotate(map, degrees(45))
+map = b.rotate(map, degrees(45))
 
-local start_circle =  circle_builder(0.3 * ball_r)
+local start_circle =  b.circle(0.3 * ball_r)
 
-local iron = builder_with_resource(scale(start_circle,0.5,0.5), resource_module_builder(full_builder, "iron-ore", value(0, 700)))
-local copper = builder_with_resource(scale(start_circle,0.5,0.5), resource_module_builder(full_builder, "copper-ore", value(0, 500)))
-local stone = builder_with_resource(scale(start_circle,0.5,0.5), resource_module_builder(full_builder, "stone", value(0, 250)))
-local oil = builder_with_resource(scale(start_circle,0.1,0.1), resource_module_builder(full_builder, "crude-oil", value(0, 40000)))
-local coal = builder_with_resource(scale(start_circle,0.5,0.5), resource_module_builder(full_builder, "coal", value(0, 800)))
+local iron = b.apply_entity(b.scale(start_circle,0.5,0.5), b.resource(b.full_shape, "iron-ore", value(0, 700)))
+local copper = b.apply_entity(b.scale(start_circle,0.5,0.5), b.resource(b.full_shape, "copper-ore", value(0, 500)))
+local stone = b.apply_entity(b.scale(start_circle,0.5,0.5), b.resource(b.full_shape, "stone", value(0, 250)))
+local oil = b.apply_entity(b.scale(start_circle,0.1,0.1), b.resource(b.full_shape, "crude-oil", value(0, 40000)))
+local coal = b.apply_entity(b.scale(start_circle,0.5,0.5), b.resource(b.full_shape, "coal", value(0, 800)))
 
-local start = compound_or
+local start = b.any
 {
-    translate(iron, 0, -9),
-    translate(copper, 0, 9),
-    translate(stone, -9, 0),
-    translate(oil, 9, 9),
-    translate(coal, 9, 0),
+    b.translate(iron, 0, -9),
+    b.translate(copper, 0, 9),
+    b.translate(stone, -9, 0),
+    b.translate(oil, 9, 9),
+    b.translate(coal, 9, 0),
     
 }
---start = change_map_gen_collision_tile(start,"water-tile", "grass-1")
-start = compound_or{start, big_circle}
+--start = b.change_map_gen_collision_tile(start,"water-tile", "grass-1")
+start = b.any{start, big_circle}
 
-map = choose(big_circle, start, map)
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.choose(big_circle, start, map)
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
-map = scale(map, 6, 6)
+map = b.scale(map, 6, 6)
 
 return map
 
diff --git a/map_gen/presets/factorio_logo.lua b/map_gen/presets/factorio_logo.lua
index 8044c128..00faeb5e 100644
--- a/map_gen/presets/factorio_logo.lua
+++ b/map_gen/presets/factorio_logo.lua
@@ -12,16 +12,18 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.factorio_logo"
-local pic = decompress(pic)
+local b = require "map_gen.shared.builders"
 
-local shape = picture_builder(pic)
-shape = scale(shape, scale_factor, scale_factor)
+local pic = require "map_gen.data.presets.factorio_logo"
+local pic = b.decompress(pic)
+
+local shape = b.picture(pic)
+shape = b.scale(shape, scale_factor, scale_factor)
 
 local pattern_width = scale_factor * pic.width + island_distance_x
 local pattern_height = scale_factor * pic.height + island_distance_y
-shape = single_pattern_builder(shape, pattern_width, pattern_height)
+shape = b.single_pattern(shape, pattern_width, pattern_height)
 
-shape = change_tile(shape, false, "deepwater")
+shape = b.change_tile(shape, false, "deepwater")
 
 return shape
\ No newline at end of file
diff --git a/map_gen/presets/factorio_logo2.lua b/map_gen/presets/factorio_logo2.lua
index 64bfe477..9053b13c 100644
--- a/map_gen/presets/factorio_logo2.lua
+++ b/map_gen/presets/factorio_logo2.lua
@@ -12,18 +12,20 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.factorio_logo2"
-local pic = decompress(pic)
+local b = require "map_gen.shared.builders"
 
-local shape = picture_builder(pic)
-shape = scale(shape, scale_factor, scale_factor)
+local pic = require "map_gen.data.presets.factorio_logo2"
+local pic = b.decompress(pic)
+
+local shape = b.picture(pic)
+shape = b.scale(shape, scale_factor, scale_factor)
 
 local pattern_width = scale_factor * pic.width + island_distance_x
 local pattern_height = scale_factor * pic.height + island_distance_y
-shape = single_pattern_builder(shape, pattern_width, pattern_height)
+shape = b.single_pattern(shape, pattern_width, pattern_height)
 
-shape = change_tile(shape, false, "water")
+shape = b.change_tile(shape, false, "water")
 
-shape = spawn_fish(shape, 0.008)
+shape = b.fish(shape, 0.008)
 
 return shape
\ No newline at end of file
diff --git a/map_gen/presets/fish_islands.lua b/map_gen/presets/fish_islands.lua
index 19a9b4f4..392ea159 100644
--- a/map_gen/presets/fish_islands.lua
+++ b/map_gen/presets/fish_islands.lua
@@ -10,17 +10,19 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 -- change these to change the pattern.
 local seed1 = 1234
 local seed2 = 5678
 
-local value = manhattan_ore_value
+local value = b.manhattan_value
 
 local pic = require "map_gen.data.presets.fish"
-local pic = decompress(pic)
-local fish = picture_builder(pic)
+local pic = b.decompress(pic)
+local fish = b.picture(pic)
 
-fish = change_tile(fish, "water", false)
+fish = b.change_tile(fish, "water", false)
 
 local ores =
     {
@@ -32,21 +34,21 @@ local ores =
         {resource_type = "crude-oil", value = value(50000, 250)},
     }
 
-local cap = translate(rectangle_builder(48, 48), 100, 0)
+local cap = b.translate(b.rectangle(48, 48), 100, 0)
 
-local iron = resource_module_builder(cap, ores[1].resource_type, ores[1].value)
-local copper = resource_module_builder(cap, ores[2].resource_type, ores[2].value)
-local stone = resource_module_builder(cap, ores[3].resource_type, ores[3].value)
-local coal = resource_module_builder(cap, ores[4].resource_type, ores[4].value)
-local uranium = resource_module_builder(cap, ores[5].resource_type, ores[5].value)
-local oil = resource_module_builder(throttle_world_xy(cap, 1, 8, 1, 8), ores[6].resource_type, ores[6].value)
+local iron = b.resource(cap, ores[1].resource_type, ores[1].value)
+local copper = b.resource(cap, ores[2].resource_type, ores[2].value)
+local stone = b.resource(cap, ores[3].resource_type, ores[3].value)
+local coal = b.resource(cap, ores[4].resource_type, ores[4].value)
+local uranium = b.resource(cap, ores[5].resource_type, ores[5].value)
+local oil = b.resource(b.throttle_world_xy(cap, 1, 8, 1, 8), ores[6].resource_type, ores[6].value)
 
-local iron_fish = builder_with_resource(fish, iron)
-local copper_fish = builder_with_resource(fish, copper)
-local stone_fish = builder_with_resource(fish, stone)
-local coal_fish = builder_with_resource(fish, coal)
-local uranium_fish = builder_with_resource(fish, uranium)
-local oil_fish = builder_with_resource(fish, oil)
+local iron_fish = b.apply_entity(fish, iron)
+local copper_fish = b.apply_entity(fish, copper)
+local stone_fish = b.apply_entity(fish, stone)
+local coal_fish = b.apply_entity(fish, coal)
+local uranium_fish = b.apply_entity(fish, uranium)
+local oil_fish = b.apply_entity(fish, oil)
 
 local fishes =
     {
@@ -77,7 +79,7 @@ for c = 1, p_cols do
     table.insert(pattern, row)
     for r = 1, p_rows do
         if (r <= 1) and (c <= 2 or c > p_cols - 1) then
-            table.insert(row, empty_builder)
+            table.insert(row, b.empty_shape)
         else
             local i = random:next_int(1, t)
             
@@ -92,57 +94,57 @@ for c = 1, p_cols do
             local y = random:next_int(-48, 48)
             local r = random:next() * tau
             
-            shape = rotate(shape, r)
-            shape = translate(shape, x, y)
+            shape = b.rotate(shape, r)
+            shape = b.translate(shape, x, y)
             
             table.insert(row, shape)
         end
     end
 end
 
-local map = grid_pattern_full_overlap_builder(pattern, p_cols, p_rows, 215, 215)
+local map = b.grid_pattern_full_overlap(pattern, p_cols, p_rows, 215, 215)
 
 local start = require "map_gen.data.presets.soy_sauce"
-start = decompress(start)
-start = picture_builder(start)
-start = change_tile(start, "water", false)
+start = b.decompress(start)
+start = b.picture(start)
+start = b.change_tile(start, "water", false)
 
 local pic = require "map_gen.data.presets.fish_black_and_white"
-local pic = decompress(pic)
-local fish_bw = picture_builder(pic)
-fish_bw = scale(fish_bw, 0.25, 0.25)
+local pic = b.decompress(pic)
+local fish_bw = b.picture(pic)
+fish_bw = b.scale(fish_bw, 0.25, 0.25)
 
-local start_copper = rotate(fish_bw, degrees(180))
-local start_stone = rotate(fish_bw, degrees(90))
-local start_coal = rotate(fish_bw, degrees(-90))
+local start_copper = b.rotate(fish_bw, degrees(180))
+local start_stone = b.rotate(fish_bw, degrees(90))
+local start_coal = b.rotate(fish_bw, degrees(-90))
 
-local start_iron = translate(fish_bw, -32, 0)
-start_copper = translate(start_copper, 32, 0)
-start_stone = translate(start_stone, 0, 32)
-start_coal = translate(start_coal, 0, -32)
+local start_iron = b.translate(fish_bw, -32, 0)
+start_copper = b.translate(start_copper, 32, 0)
+start_stone = b.translate(start_stone, 0, 32)
+start_coal = b.translate(start_coal, 0, -32)
 
-start_iron = resource_module_builder(start_iron, ores[1].resource_type, value(1000, 0.5))
-start_copper = resource_module_builder(start_copper, ores[2].resource_type, value(800, 0.5))
-start_stone = resource_module_builder(start_stone, ores[3].resource_type, value(600, 0.5))
-start_coal = resource_module_builder(start_coal, ores[4].resource_type, value(600, 0.5))
+start_iron = b.resource(start_iron, ores[1].resource_type, value(1000, 0.5))
+start_copper = b.resource(start_copper, ores[2].resource_type, value(800, 0.5))
+start_stone = b.resource(start_stone, ores[3].resource_type, value(600, 0.5))
+start_coal = b.resource(start_coal, ores[4].resource_type, value(600, 0.5))
 
-local start_oil = translate(rectangle_builder(1, 1), -44, 74)
-start_oil = resource_module_builder(start_oil, ores[6].resource_type, value(100000, 0))
+local start_oil = b.translate(b.rectangle(1, 1), -44, 74)
+start_oil = b.resource(start_oil, ores[6].resource_type, value(100000, 0))
 
-local worms = rectangle_builder(150, 72)
-worms = translate(worms, 0, -210)
-worms = spawn_entity(worms, "big-worm-turret")
+local worms = b.rectangle(150, 72)
+worms = b.translate(worms, 0, -210)
+worms = b.entity(worms, "big-worm-turret")
 
-local start = builder_with_resource(start, compound_or{start_iron, start_copper, start_stone, start_coal, start_oil, worms})
+local start = b.apply_entity(start, b.any{start_iron, start_copper, start_stone, start_coal, start_oil, worms})
 
-map = shape_or_else(start, map)
+map = b.if_else(start, map)
 
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
-local sea = tile_builder("water")
-local sea = spawn_fish(sea, 0.025)
+local sea = b.tile("water")
+local sea = b.fish(sea, 0.025)
 
-map = shape_or_else(map, sea)
+map = b.if_else(map, sea)
 
---map = scale(map, 2, 2)
+--map = b.scale(map, 2, 2)
 return map
diff --git a/map_gen/presets/fractal_balls.lua b/map_gen/presets/fractal_balls.lua
index aef45814..ab511c0b 100644
--- a/map_gen/presets/fractal_balls.lua
+++ b/map_gen/presets/fractal_balls.lua
@@ -2,6 +2,8 @@
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local function value(base, mult)
     return function(x, y) 
         return mult * (math.abs(x) + math.abs(y)) + base
@@ -16,103 +18,103 @@ local function no_resources(x, y, world, tile)
     return tile
 end
 
-local arm1 = translate(rectangle_builder(2, 3), 0, -5)
-local arm2 = translate(rectangle_builder(6, 2), 0, 22)
+local arm1 = b.translate(b.rectangle(2, 3), 0, -5)
+local arm2 = b.translate(b.rectangle(6, 2), 0, 22)
 
-local inner = circle_builder(22)
-local outer = circle_builder(24)
-local ring = compound_and{outer, invert(inner)}
+local inner = b.circle(22)
+local outer = b.circle(24)
+local ring = b.all{outer, b.invert(inner)}
 
-map = compound_or{map, ring}
+map = b.any{map, ring}
 
-local arms = compound_or{arm1, arm2}
-arms = translate(arms, 0, -16)
-arms = compound_or
+local arms = b.any{arm1, arm2}
+arms = b.translate(arms, 0, -16)
+arms = b.any
 {
     arms, 
-    rotate(arms, degrees(120)),
-    rotate(arms, degrees(-120))
+    b.rotate(arms, degrees(120)),
+    b.rotate(arms, degrees(-120))
 }
-local frame = compound_or{arms, ring}
+local frame = b.any{arms, ring}
 
-local ball = circle_builder(8)
+local ball = b.circle(8)
 
-local iron = resource_module_builder(circle_builder(6), "iron-ore", value(1000, 1))
-local copper = resource_module_builder(circle_builder(6), "copper-ore", value(800, 0.8))
-local stone = resource_module_builder(circle_builder(4), "stone", value(500, .5))
-local coal = resource_module_builder(circle_builder(6), "coal", value(600, 0.6))
-local uranium = resource_module_builder(circle_builder(4), "uranium-ore", value(400, 1))
-local oil = resource_module_builder(throttle_world_xy(circle_builder(6), 1, 4, 1, 4), "crude-oil", value(100000, 50))
+local iron = b.resource(b.circle(6), "iron-ore", value(1000, 1))
+local copper = b.resource(b.circle(6), "copper-ore", value(800, 0.8))
+local stone = b.resource(b.circle(4), "stone", value(500, .5))
+local coal = b.resource(b.circle(6), "coal", value(600, 0.6))
+local uranium = b.resource(b.circle(4), "uranium-ore", value(400, 1))
+local oil = b.resource(b.throttle_world_xy(b.circle(6), 1, 4, 1, 4), "crude-oil", value(100000, 50))
 
-local iron_ball = change_map_gen_collision_tile(builder_with_resource(ball, iron),"water-tile", "grass-1")
-local copper_ball = change_map_gen_collision_tile(builder_with_resource(ball, copper),"water-tile", "grass-1")
-local stone_ball = change_map_gen_collision_tile(builder_with_resource(ball, stone),"water-tile", "grass-1")
-local coal_ball = change_map_gen_collision_tile(builder_with_resource(ball, coal),"water-tile", "grass-1")
-local uranium_ball = change_map_gen_collision_tile(builder_with_resource(ball, uranium),"water-tile", "grass-1")
-local oil_ball = change_map_gen_collision_tile(builder_with_resource(ball, oil),"water-tile", "grass-1")
+local iron_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, iron),"water-tile", "grass-1")
+local copper_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, copper),"water-tile", "grass-1")
+local stone_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, stone),"water-tile", "grass-1")
+local coal_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, coal),"water-tile", "grass-1")
+local uranium_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, uranium),"water-tile", "grass-1")
+local oil_ball = b.change_map_gen_collision_tile(b.apply_entity(ball, oil),"water-tile", "grass-1")
 
-local balls1 = compound_or
+local balls1 = b.any
 {
-    translate(iron_ball, 0, -12),
-    rotate(translate(copper_ball, 0, -12), degrees(120)),
-    rotate(translate(coal_ball, 0, -12), degrees(-120)),  
+    b.translate(iron_ball, 0, -12),
+    b.rotate(b.translate(copper_ball, 0, -12), degrees(120)),
+    b.rotate(b.translate(coal_ball, 0, -12), degrees(-120)),  
     frame
 }
---shape = rotate(shape, degrees(rot))
-balls1 = rotate(balls1, degrees(180))
-balls1 = choose(outer, balls1, empty_builder)
-balls1 = translate(balls1, 0, -36)
+--shape = b.rotate(shape, degrees(rot))
+balls1 = b.rotate(balls1, degrees(180))
+balls1 = b.choose(outer, balls1, b.empty_shape)
+balls1 = b.translate(balls1, 0, -36)
 
-local balls2 = compound_or
+local balls2 = b.any
 {
-    translate(iron_ball, 0, -12),
-    rotate(translate(copper_ball, 0, -12), degrees(120)),
-    rotate(translate(stone_ball, 0, -12), degrees(-120)),  
+    b.translate(iron_ball, 0, -12),
+    b.rotate(b.translate(copper_ball, 0, -12), degrees(120)),
+    b.rotate(b.translate(stone_ball, 0, -12), degrees(-120)),  
     frame
 }
-balls2 = rotate(balls2, degrees(180))
-balls2  = choose(outer, balls2, empty_builder)
-balls2 = translate(balls2, 0, -36)
-balls2 = rotate(balls2, degrees(120))
+balls2 = b.rotate(balls2, degrees(180))
+balls2  = b.choose(outer, balls2, b.empty_shape)
+balls2 = b.translate(balls2, 0, -36)
+balls2 = b.rotate(balls2, degrees(120))
 
-local balls3 = compound_or
+local balls3 = b.any
 {
-    translate(iron_ball, 0, -12),
-    rotate(translate(uranium_ball, 0, -12), degrees(120)),
-    rotate(translate(oil_ball, 0, -12), degrees(-120)),  
+    b.translate(iron_ball, 0, -12),
+    b.rotate(b.translate(uranium_ball, 0, -12), degrees(120)),
+    b.rotate(b.translate(oil_ball, 0, -12), degrees(-120)),  
     frame
 }
-balls3 = rotate(balls3, degrees(180))
-balls3  = choose(outer, balls3, empty_builder)
-balls3 = translate(balls3, 0, -36)
-balls3 = rotate(balls3, degrees(-120))
+balls3 = b.rotate(balls3, degrees(180))
+balls3  = b.choose(outer, balls3, b.empty_shape)
+balls3 = b.translate(balls3, 0, -36)
+balls3 = b.rotate(balls3, degrees(-120))
 
 
-local balls4 = compound_or
+local balls4 = b.any
 {
     balls1,
     balls2,
     balls3,
-    scale(frame, 3, 3)
+    b.scale(frame, 3, 3)
 }
-balls4 = rotate(balls4, degrees(180))
-balls4 = apply_effect(balls4, no_resources)
-balls4 = choose(scale(outer, 3, 3), balls4, empty_builder)
+balls4 = b.rotate(balls4, degrees(180))
+balls4 = b.apply_effect(balls4, no_resources)
+balls4 = b.choose(b.scale(outer, 3, 3), balls4, b.empty_shape)
 
 local function make_ball(shape, sf)
-    local s1 = translate(shape, 0, -12 * sf)
-    local shape = compound_or
+    local s1 = b.translate(shape, 0, -12 * sf)
+    local shape = b.any
     {
         s1, 
-        rotate(s1, degrees(120)),
-        rotate(s1, degrees(-120)),
-        scale(frame, sf, sf)
+        b.rotate(s1, degrees(120)),
+        b.rotate(s1, degrees(-120)),
+        b.scale(frame, sf, sf)
     }
-    shape = rotate(shape, degrees(180))
+    shape = b.rotate(shape, degrees(180))
 
-    local bound = scale(outer, sf, sf)
+    local bound = b.scale(outer, sf, sf)
 
-    return choose(bound, shape, empty_builder)    
+    return b.choose(bound, shape, b.empty_shape)    
 end
 
 local ratio = 24 / 8 
@@ -123,7 +125,7 @@ for i = 1, 6 do
     total_sf = ratio * total_sf
 end
 
-map = translate(map, 0, -19680)
-map = scale(map, 1.5, 1.5)
+map = b.translate(map, 0, -19680)
+map = b.scale(map, 1.5, 1.5)
 
 return map
diff --git a/map_gen/presets/fruit_loops.lua b/map_gen/presets/fruit_loops.lua
index c5df0668..c7cb6371 100644
--- a/map_gen/presets/fruit_loops.lua
+++ b/map_gen/presets/fruit_loops.lua
@@ -10,6 +10,8 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 -- change these to change the pattern.
 local seed1 = 9999
 local seed2 = 6666
@@ -20,10 +22,10 @@ local function value(base, mult)
     end
 end
 
-local big_circle = circle_builder(48)
-local small_circle = circle_builder(24)
+local big_circle = b.circle(48)
+local small_circle = b.circle(24)
 
-local ring = compound_and{big_circle, invert(small_circle)}
+local ring = b.all{big_circle, b.invert(small_circle)}
 
 local ores =
     {
@@ -35,12 +37,12 @@ local ores =
         {resource_type = "crude-oil", value = value(10000, 50)},
     }
 
-local iron = resource_module_builder(full_builder, ores[1].resource_type, ores[1].value)
-local copper = resource_module_builder(full_builder, ores[2].resource_type, ores[2].value)
-local stone = resource_module_builder(full_builder, ores[3].resource_type, ores[3].value)
-local coal = resource_module_builder(full_builder, ores[4].resource_type, ores[4].value)
-local uranium = resource_module_builder(full_builder, ores[5].resource_type, ores[5].value)
-local oil = resource_module_builder(throttle_world_xy(full_builder, 1, 4, 1, 4), ores[6].resource_type, ores[6].value)
+local iron = b.resource(b.full_shape, ores[1].resource_type, ores[1].value)
+local copper = b.resource(b.full_shape, ores[2].resource_type, ores[2].value)
+local stone = b.resource(b.full_shape, ores[3].resource_type, ores[3].value)
+local coal = b.resource(b.full_shape, ores[4].resource_type, ores[4].value)
+local uranium = b.resource(b.full_shape, ores[5].resource_type, ores[5].value)
+local oil = b.resource(b.throttle_world_xy(b.full_shape, 1, 4, 1, 4), ores[6].resource_type, ores[6].value)
 
 local function striped(x, y, world_x, world_y, surface)
     local t = (world_x + world_y) % 4 + 1
@@ -65,28 +67,28 @@ local function sprinkle(x, y, world_x, world_y, surface)
     }
 end
 
-local segmented = segment_pattern_builder({iron, copper, stone, coal})
+local segmented = b.segment_pattern({iron, copper, stone, coal})
 
-local tree = spawn_entity(throttle_world_xy(full_builder, 1, 3, 1, 3), "tree-01")
+local tree = b.entity(b.throttle_world_xy(b.full_shape, 1, 3, 1, 3), "tree-01")
 
-local start_iron = resource_module_builder(ring, ores[1].resource_type, value(500, 0.5))
-local start_copper = resource_module_builder(ring, ores[2].resource_type, value(400, 0.5))
-local start_stone = resource_module_builder(ring, ores[3].resource_type, value(300, 0.5))
-local start_coal = resource_module_builder(ring, ores[4].resource_type, value(300, 0.5))
-local start_segmented = segment_pattern_builder({start_iron, start_copper, start_stone, start_coal})
-local start_tree = spawn_entity(throttle_world_xy(small_circle, 1, 3, 1, 3), "tree-01")
+local start_iron = b.resource(ring, ores[1].resource_type, value(500, 0.5))
+local start_copper = b.resource(ring, ores[2].resource_type, value(400, 0.5))
+local start_stone = b.resource(ring, ores[3].resource_type, value(300, 0.5))
+local start_coal = b.resource(ring, ores[4].resource_type, value(300, 0.5))
+local start_segmented = b.segment_pattern({start_iron, start_copper, start_stone, start_coal})
+local start_tree = b.entity(b.throttle_world_xy(small_circle, 1, 3, 1, 3), "tree-01")
 
-local iron_loop = builder_with_resource(ring, iron)
-local copper_loop = builder_with_resource(ring, copper)
-local stone_loop = builder_with_resource(ring, stone)
-local coal_loop = builder_with_resource(ring, coal)
-local uranium_loop = builder_with_resource(ring, uranium)
-local oil_loop = builder_with_resource(ring, oil)
-local striped_loop = builder_with_resource(ring, striped)
-local sprinkle_loop = builder_with_resource(ring, sprinkle)
-local segmented_loop = builder_with_resource(ring, segmented)
-local tree_loop = builder_with_resource(ring, tree)
-local start_loop = builder_with_resource(big_circle, compound_or{start_segmented, start_tree})
+local iron_loop = b.apply_entity(ring, iron)
+local copper_loop = b.apply_entity(ring, copper)
+local stone_loop = b.apply_entity(ring, stone)
+local coal_loop = b.apply_entity(ring, coal)
+local uranium_loop = b.apply_entity(ring, uranium)
+local oil_loop = b.apply_entity(ring, oil)
+local striped_loop = b.apply_entity(ring, striped)
+local sprinkle_loop = b.apply_entity(ring, sprinkle)
+local segmented_loop = b.apply_entity(ring, segmented)
+local tree_loop = b.apply_entity(ring, tree)
+local start_loop = b.apply_entity(big_circle, b.any{start_segmented, start_tree})
 
 local loops =
     {
@@ -135,22 +137,22 @@ for c = 1, p_cols do
             local x = random:next_int(-32, 32)
             local y = random:next_int(-32, 32)
             
-            shape = translate(shape, x, y)
+            shape = b.translate(shape, x, y)
             
             table.insert(row, shape)
         end
     end
 end
 
-local map = grid_pattern_full_overlap_builder(pattern, p_cols, p_rows, 128, 128)
+local map = b.grid_pattern_full_overlap(pattern, p_cols, p_rows, 128, 128)
 
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
-local sea = change_tile(full_builder, true, "water")
-local sea = spawn_fish(sea, 0.025)
+local sea = b.change_tile(b.full_shape, true, "water")
+local sea = b.fish(sea, 0.025)
 
-map = shape_or_else(map, sea)
+map = b.if_else(map, sea)
 
---map = translate(map, -32, 0)
---map = scale(map, 1, 1)
+--map = b.translate(map, -32, 0)
+--map = b.scale(map, 1, 1)
 return map
diff --git a/map_gen/presets/gears.lua b/map_gen/presets/gears.lua
index eb14ed86..2c8ae767 100644
--- a/map_gen/presets/gears.lua
+++ b/map_gen/presets/gears.lua
@@ -9,16 +9,18 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.gears"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
+local shape = b.picture(pic)
 
-local map = single_pattern_builder(shape, pic.width, pic.height)
-map = translate(map, -20, 20)
-map = scale(map, 4, 4)
+local map = b.single_pattern(shape, pic.width, pic.height)
+map = b.translate(map, -20, 20)
+map = b.scale(map, 4, 4)
 
-map = change_tile(map, false, "water")
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_tile(map, false, "water")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/goat.lua b/map_gen/presets/goat.lua
index eddb369f..39b8b849 100644
--- a/map_gen/presets/goat.lua
+++ b/map_gen/presets/goat.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 require "map_gen.shared.generate_not_threaded"
 --require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.goat"
-local pic = decompress(pic)
+local pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = translate(shape, 10, -96)
-shape = scale(shape,2,2)
---shape = rotate(shape, degrees(0))
+local shape = b.picture(pic)
+shape = b.translate(shape, 10, -96)
+shape = b.scale(shape,2,2)
+--shape = b.rotate(shape, degrees(0))
 
--- shape = change_tile(shape, false, "deepwater")
+-- shape = b.change_tile(shape, false, "deepwater")
 
 return shape
diff --git a/map_gen/presets/goats_on_goats.lua b/map_gen/presets/goats_on_goats.lua
index fbc21a06..74d94364 100644
--- a/map_gen/presets/goats_on_goats.lua
+++ b/map_gen/presets/goats_on_goats.lua
@@ -5,15 +5,17 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.goat"
-local pic = decompress(pic)
-    
-local goat1 = picture_builder(pic)   
-goat1 = invert(goat1)
-local crop = rectangle_builder(pic.width, pic.height)
-goat1 = compound_and{goat1, crop}
+local b = require "map_gen.shared.builders"
 
-local floor = translate(rectangle_builder(pic.width, 32), 0 , (pic.height / 2) + 12)
+local pic = require "map_gen.data.presets.goat"
+local pic = b.decompress(pic)
+    
+local goat1 = b.picture(pic)   
+goat1 = b.invert(goat1)
+local crop = b.rectangle(pic.width, pic.height)
+goat1 = b.all{goat1, crop}
+
+local floor = b.translate(b.rectangle(pic.width, 32), 0 , (pic.height / 2) + 12)
 
 local goats = { floor, goat1 }
 
@@ -24,14 +26,14 @@ local t = 0
 for i = 1, 5 do
     s = s * sf
     t = t + (s * tf * pic.height)
-    local goat = translate(scale(goat1, s, s), 0, -t)
+    local goat = b.translate(b.scale(goat1, s, s), 0, -t)
     table.insert( goats, goat )        
 end
 
-local ceiling = translate(rectangle_builder(pic.width, 32), 0 , -t - 32)
+local ceiling = b.translate(b.rectangle(pic.width, 32), 0 , -t - 32)
 table.insert( goats, ceiling )  
 
-local shape = translate(compound_or(goats), 0, (t / 2) - 60)
+local shape = b.translate(b.any(goats), 0, (t / 2) - 60)
 
 -- for custom goat ores
 --[[
@@ -45,20 +47,20 @@ local function rot(table)
     return copy
 end
 
-local patch = flip_x(goat1)
---patch = throttle_xy(patch, 1, 2, 1 ,2)
-local iron_patch = resource_module_builder(scale(patch,0.12,0.12), "iron-ore", function(x,y) return 500 end)
-local copper_patch = resource_module_builder(scale(patch,0.12,0.12), "copper-ore", function(x,y) return 500 end)
-local coal_patch = resource_module_builder(scale(patch,0.12,0.12), "coal", function(x,y) return 500 end)
-local stone_patch = resource_module_builder(scale(patch,0.12,0.12), "stone", function(x,y) return 500 end)
-local uraniumn_patch = resource_module_builder(scale(patch,0.12,0.12), "uraniumn-ore", function(x,y) return 500 end)
-local oil_patch = resource_module_builder(scale(patch,0.12,0.12), "crude-oil", function(x,y) return 500 end)
-local patch1 = translate(scale(patch,0.2,0.2),0,170)
-local patch2 = translate(scale(patch,0.15,0.15),0,25)
-local patch3 = translate(scale(patch,0.12,0.12),0,-88)
-local patch4 = translate(scale(patch,0.1,0.1),0,-173)
-local patch5 = translate(scale(patch,0.08,0.08),0,-238)
-local patch6 = translate(scale(patch,0.04,0.04),0,-282)
+local patch = b.flip_x(goat1)
+--patch = b.throttle_xy(patch, 1, 2, 1 ,2)
+local iron_patch = b.resource(b.scale(patch,0.12,0.12), "iron-ore", function(x,y) return 500 end)
+local copper_patch = b.resource(b.scale(patch,0.12,0.12), "copper-ore", function(x,y) return 500 end)
+local coal_patch = b.resource(b.scale(patch,0.12,0.12), "coal", function(x,y) return 500 end)
+local stone_patch = b.resource(b.scale(patch,0.12,0.12), "stone", function(x,y) return 500 end)
+local uraniumn_patch = b.resource(b.scale(patch,0.12,0.12), "uraniumn-ore", function(x,y) return 500 end)
+local oil_patch = b.resource(b.scale(patch,0.12,0.12), "crude-oil", function(x,y) return 500 end)
+local patch1 = b.translate(b.scale(patch,0.2,0.2),0,170)
+local patch2 = b.translate(b.scale(patch,0.15,0.15),0,25)
+local patch3 = b.translate(b.scale(patch,0.12,0.12),0,-88)
+local patch4 = b.translate(b.scale(patch,0.1,0.1),0,-173)
+local patch5 = b.translate(b.scale(patch,0.08,0.08),0,-238)
+local patch6 = b.translate(b.scale(patch,0.04,0.04),0,-282)
 local patch_table = { patch1, patch2, patch3, patch4, patch5, patch6 }
 local function do_nothing(builder, x, y) return builder(x, y) end
 local function throttle(builder, x, y)         
@@ -101,16 +103,16 @@ local function res_builder(x, y, world_x, world_y)
         end
     end
 end
---local patches = compound_or(patch_table)
---local iron = resource_module_builder(patches,"iron-ore", function(x,y) return 400 end)
---local iron_goat = builder_with_resource(shape, iron)
-local res_goat = builder_with_resource(shape, res_builder)
+--local patches = b.any(patch_table)
+--local iron = b.resource(patches,"iron-ore", function(x,y) return 400 end)
+--local iron_goat = b.apply_entity(shape, iron)
+local res_goat = b.apply_entity(shape, res_builder)
 shape = res_goat
 --]]
 
-local shape2 = flip_x(shape)
-local shape3 = flip_y(shape)
-local shape4 = flip_y(shape2)    
+local shape2 = b.flip_x(shape)
+local shape3 = b.flip_y(shape)
+local shape4 = b.flip_y(shape2)    
 
 local pattern =
 {
@@ -118,7 +120,7 @@ local pattern =
     {shape3, shape4},
 }  
 
-local map = grid_pattern_builder(pattern, 2, 2, pic.width, pic.height + t - 105)
-map = change_map_gen_collision_tile(map,"water-tile", "water-green")
+local map = b.grid_pattern(pattern, 2, 2, pic.width, pic.height + t - 105)
+map = b.change_map_gen_collision_tile(map,"water-tile", "water-green")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/grid_islands.lua b/map_gen/presets/grid_islands.lua
index 4e5a6416..aa02e4c6 100644
--- a/map_gen/presets/grid_islands.lua
+++ b/map_gen/presets/grid_islands.lua
@@ -9,46 +9,48 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local square = rectangle_builder(160,160)
-local circle = circle_builder(60)  
+local b = require "map_gen.shared.builders"
 
-local leg = rectangle_builder(32,480)
-local head = translate (oval_builder(32, 64), 0, -64)
-local body = translate (circle_builder(64), 0, 64)
+local square = b.rectangle(160,160)
+local circle = b.circle(60)  
+
+local leg = b.rectangle(32,480)
+local head = b.translate (b.oval(32, 64), 0, -64)
+local body = b.translate (b.circle(64), 0, 64)
 
 local count = 10
 local angle = 360 / count
 local list = { head, body }
 for i = 1, (count / 2) - 1 do
-    local shape = rotate(leg, degrees(i * angle))
+    local shape = b.rotate(leg, degrees(i * angle))
     table.insert( list, shape )
 end  
 
-local spider = compound_or(list)   
+local spider = b.any(list)   
 
-local patch = scale(spider, 0.125, 0.125)
-local iron_patch = resource_module_builder(patch, "iron-ore", function(x,y) return 500 + (math.abs(x) + math.abs(y)) end)
-local copper_patch = resource_module_builder(patch, "copper-ore",function(x,y) return 400 + (math.abs(x) + math.abs(y)) * 0.8  end)
-local coal_patch = resource_module_builder(patch, "coal",function(x,y) return 300 + (math.abs(x) + math.abs(y)) * 0.7  end)
-local stone_patch = resource_module_builder(patch, "stone",function(x,y) return 100 + (math.abs(x) + math.abs(y)) * 0.5 end)
-local uraniumn_patch = resource_module_builder(scale(patch, 0.5,0.5), "uranium-ore",function(x,y) return 100 + (math.abs(x) + math.abs(y)) * 0.2 end)   
-local oil_patch = resource_module_builder(patch, "crude-oil",function(x,y) return 75000 + (math.abs(x) + math.abs(y)) * 500 end)
+local patch = b.scale(spider, 0.125, 0.125)
+local iron_patch = b.resource(patch, "iron-ore", function(x,y) return 500 + (math.abs(x) + math.abs(y)) end)
+local copper_patch = b.resource(patch, "copper-ore",function(x,y) return 400 + (math.abs(x) + math.abs(y)) * 0.8  end)
+local coal_patch = b.resource(patch, "coal",function(x,y) return 300 + (math.abs(x) + math.abs(y)) * 0.7  end)
+local stone_patch = b.resource(patch, "stone",function(x,y) return 100 + (math.abs(x) + math.abs(y)) * 0.5 end)
+local uraniumn_patch = b.resource(b.scale(patch, 0.5,0.5), "uranium-ore",function(x,y) return 100 + (math.abs(x) + math.abs(y)) * 0.2 end)   
+local oil_patch = b.resource(patch, "crude-oil",function(x,y) return 75000 + (math.abs(x) + math.abs(y)) * 500 end)
 
-local iron_circle = builder_with_resource(circle, iron_patch)
-local copper_circle = builder_with_resource(circle, copper_patch)
-local coal_circle = builder_with_resource(circle, coal_patch)
-local stone_circle = builder_with_resource(circle, stone_patch)
-local uraniumn_circle = builder_with_resource(circle, uraniumn_patch)
-local oil_circle = builder_with_resource(circle, oil_patch)
+local iron_circle = b.apply_entity(circle, iron_patch)
+local copper_circle = b.apply_entity(circle, copper_patch)
+local coal_circle = b.apply_entity(circle, coal_patch)
+local stone_circle = b.apply_entity(circle, stone_patch)
+local uraniumn_circle = b.apply_entity(circle, uraniumn_patch)
+local oil_circle = b.apply_entity(circle, oil_patch)
 
-local start_patch = scale(spider, 0.0625, 0.0625)
-local start_iron_patch = resource_module_builder(translate(start_patch, 48, 0), "iron-ore", function(x,y) return 500 end)
-local start_copper_patch = resource_module_builder(translate(start_patch, 0, -48), "copper-ore", function(x,y) return 400 end)
-local start_stone_patch = resource_module_builder(translate(start_patch, -48, 0), "stone", function(x,y) return 200 end)
-local start_coal_patch = resource_module_builder(translate(start_patch, 0, 48), "coal", function(x,y) return 300 end)
+local start_patch = b.scale(spider, 0.0625, 0.0625)
+local start_iron_patch = b.resource(b.translate(start_patch, 48, 0), "iron-ore", function(x,y) return 500 end)
+local start_copper_patch = b.resource(b.translate(start_patch, 0, -48), "copper-ore", function(x,y) return 400 end)
+local start_stone_patch = b.resource(b.translate(start_patch, -48, 0), "stone", function(x,y) return 200 end)
+local start_coal_patch = b.resource(b.translate(start_patch, 0, 48), "coal", function(x,y) return 300 end)
 
-local start_resources = compound_or({ start_iron_patch, start_copper_patch, start_stone_patch, start_coal_patch })
-local start = builder_with_resource(square_diamond_builder(224), start_resources)
+local start_resources = b.any({ start_iron_patch, start_copper_patch, start_stone_patch, start_coal_patch })
+local start = b.apply_entity(b.square_diamond(224), start_resources)
 
 pattern =
 {
@@ -60,12 +62,12 @@ pattern =
     { copper_circle, square, iron_circle, square, coal_circle, square },
 }
 
-local map = grid_pattern_builder(pattern, 6, 6, 288, 288)
-map = choose(rectangle_builder(288,288), start, map)
+local map = b.grid_pattern(pattern, 6, 6, 288, 288)
+map = b.choose(b.rectangle(288,288), start, map)
 
-local path = path_builder(16)
-local paths = single_pattern_builder(path, 288, 288)
+local path = b.path(16)
+local paths = b.single_pattern(path, 288, 288)
 
-map = compound_or{map, paths}
+map = b.any{map, paths}
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/hearts.lua b/map_gen/presets/hearts.lua
index 2c3b98c9..4aa98e38 100644
--- a/map_gen/presets/hearts.lua
+++ b/map_gen/presets/hearts.lua
@@ -2,21 +2,23 @@
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local circle = circle_builder(16)
-local square = rectangle_builder(30)
-square = rotate(square, degrees(45))
+local b = require "map_gen.shared.builders"
 
-local heart = compound_or{translate(circle, -14, 0), translate(circle, 14, 0), translate(square, 0, 14)}
---local hollow_heart = compound_and{invert(heart), scale(heart, 2, 2)}
+local circle = b.circle(16)
+local square = b.rectangle(30)
+square = b.rotate(square, degrees(45))
 
-heart = translate(heart, 0, -10)
-heart = scale(heart, 51/60, 1)
-local hearts = grow(heart, heart, 52, 0.5)
+local heart = b.any{b.translate(circle, -14, 0), b.translate(circle, 14, 0), b.translate(square, 0, 14)}
+--local hollow_heart = b.all{b.invert(heart), b.scale(heart, 2, 2)}
 
-local line = line_y_builder(2)
+heart = b.translate(heart, 0, -10)
+heart = b.scale(heart, 51/60, 1)
+local hearts = b.grow(heart, heart, 52, 0.5)
 
-local map = compound_or{line, hearts}
-map = translate(map, 0, 16)
-map = scale(map, 12,12)
+local line = b.line_y(2)
+
+local map = b.any{line, hearts}
+map = b.translate(map, 0, 16)
+map = b.scale(map, 12,12)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/honeycomb.lua b/map_gen/presets/honeycomb.lua
index 84aba4d6..c7c46694 100644
--- a/map_gen/presets/honeycomb.lua
+++ b/map_gen/presets/honeycomb.lua
@@ -5,20 +5,22 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.honeycomb"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
 -- this builds the map by duplicating the pic in every direction
-map = single_pattern_builder(map, pic.width-1, pic.height-1)
+map = b.single_pattern(map, pic.width-1, pic.height-1)
 
 -- this changes the size of the map
---map = scale(map, 2, 2)
+--map = b.scale(map, 2, 2)
 
 -- this moves the map, effectively changing the spawn point.
---map = translate(map, 0, -200)
+--map = b.translate(map, 0, -200)
 
 -- this sets the tile outside the bounds of the map to deepwater, remove this and it will be void.
---map = change_tile(map, false, "deepwater")
+--map = b.change_tile(map, false, "deepwater")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/lines.lua b/map_gen/presets/lines.lua
index bab1c512..2c7efe22 100644
--- a/map_gen/presets/lines.lua
+++ b/map_gen/presets/lines.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.lines"
-pic= decompress(pic)
+pic= b.decompress(pic)
 
-local shape = picture_builder(pic)
+local shape = b.picture(pic)
 
-local map = single_pattern_builder(shape, pic.width, pic.height)
+local map = b.single_pattern(shape, pic.width, pic.height)
 
---map = translate(map, 10, -96)
-map = scale(map,10,10)
+--map = b.translate(map, 10, -96)
+map = b.scale(map,10,10)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/lines_and_balls.lua b/map_gen/presets/lines_and_balls.lua
index ddf2463f..09a205ce 100644
--- a/map_gen/presets/lines_and_balls.lua
+++ b/map_gen/presets/lines_and_balls.lua
@@ -5,44 +5,46 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local big_circle = circle_builder(150)
-local small_circle = circle_builder(140)
-local crop = rectangle_builder(300,150)
-crop = translate(crop,0,-75)
-local arc = compound_and{big_circle, invert(small_circle), invert(crop)}
-arc = scale(arc,12,4)
+local b = require "map_gen.shared.builders"
 
-local circle = circle_builder(200)
-local ball1 = translate(circle, 0,820)
-local ball2 = translate(circle, -920,740)
-local ball3 = translate(circle, 920,740)
-local rectangle = rectangle_builder(25,40)
-local arm1 = translate(rectangle, 0, 610)
-local arm2 = translate(rectangle, -920, 530)
-local arm3 = translate(rectangle, 920, 530)
+local big_circle = b.circle(150)
+local small_circle = b.circle(140)
+local crop = b.rectangle(300,150)
+crop = b.translate(crop,0,-75)
+local arc = b.all{big_circle, b.invert(small_circle), b.invert(crop)}
+arc = b.scale(arc,12,4)
 
-local arc1 = compound_or{arc, ball1,ball2,ball3,arm1,arm2,arm3}
-arc1 = single_pattern_builder(arc1, 2760,2760)
+local circle = b.circle(200)
+local ball1 = b.translate(circle, 0,820)
+local ball2 = b.translate(circle, -920,740)
+local ball3 = b.translate(circle, 920,740)
+local rectangle = b.rectangle(25,40)
+local arm1 = b.translate(rectangle, 0, 610)
+local arm2 = b.translate(rectangle, -920, 530)
+local arm3 = b.translate(rectangle, 920, 530)
+
+local arc1 = b.any{arc, ball1,ball2,ball3,arm1,arm2,arm3}
+arc1 = b.single_pattern(arc1, 2760,2760)
 
 local root2 = math.sqrt(2)
-circle = circle_builder(200 / root2)
-ball1 = translate(circle, -0,770)
-ball2 = translate(circle, -920,690)
-ball3 = translate(circle, 920,690)
-rectangle = rectangle_builder(25,40)
-arm1 = translate(rectangle, 0, 610)
-arm2 = translate(rectangle, -920, 530)
-arm3 = translate(rectangle, 920, 530)
+circle = b.circle(200 / root2)
+ball1 = b.translate(circle, -0,770)
+ball2 = b.translate(circle, -920,690)
+ball3 = b.translate(circle, 920,690)
+rectangle = b.rectangle(25,40)
+arm1 = b.translate(rectangle, 0, 610)
+arm2 = b.translate(rectangle, -920, 530)
+arm3 = b.translate(rectangle, 920, 530)
 
-local arc2 = compound_or{arc, ball1,ball2,ball3,arm1,arm2,arm3}
-arc2 = single_pattern_builder(arc2, 2760,2760)
+local arc2 = b.any{arc, ball1,ball2,ball3,arm1,arm2,arm3}
+arc2 = b.single_pattern(arc2, 2760,2760)
 
-local arc2 = rotate(arc2,degrees(45))
-arc2 = scale(arc2, root2,root2)
-arc2 = translate(arc2, -330,-1375)
+local arc2 = b.rotate(arc2,degrees(45))
+arc2 = b.scale(arc2, root2,root2)
+arc2 = b.translate(arc2, -330,-1375)
 
-local map = compound_or{arc1,arc2}
-map = translate(map,0,-700)
---map = scale(map, .2, .2)
+local map = b.any{arc1,arc2}
+map = b.translate(map,0,-700)
+--map = b.scale(map, .2, .2)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/manhattan.lua b/map_gen/presets/manhattan.lua
index 6ec33c13..62012e77 100644
--- a/map_gen/presets/manhattan.lua
+++ b/map_gen/presets/manhattan.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.manhattan"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = translate(shape, 10, -96)
-shape = scale(shape,2,2)
-shape = rotate(shape, degrees(-22.5))
+local shape = b.picture(pic)
+shape = b.translate(shape, 10, -96)
+shape = b.scale(shape,2,2)
+shape = b.rotate(shape, degrees(-22.5))
 
-shape = change_tile(shape, false, "deepwater")
+shape = b.change_tile(shape, false, "deepwater")
 
 return shape
\ No newline at end of file
diff --git a/map_gen/presets/maori.lua b/map_gen/presets/maori.lua
index c609d686..793d4df3 100644
--- a/map_gen/presets/maori.lua
+++ b/map_gen/presets/maori.lua
@@ -5,17 +5,19 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.maori"
-pic= decompress(pic)
+pic= b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = invert(shape)
-local crop = rectangle_builder(pic.width, pic.height)
-shape = compound_and{shape, crop}
+local shape = b.picture(pic)
+shape = b.invert(shape)
+local crop = b.rectangle(pic.width, pic.height)
+shape = b.all{shape, crop}
 
-local map = single_pattern_builder(shape, pic.width, pic.height)
+local map = b.single_pattern(shape, pic.width, pic.height)
 
-map = translate(map, 10, -96)
-map = scale(map,12,12)
+map = b.translate(map, 10, -96)
+map = b.scale(map,12,12)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/misc_stuff.lua b/map_gen/presets/misc_stuff.lua
index 15872179..f34b26bf 100644
--- a/map_gen/presets/misc_stuff.lua
+++ b/map_gen/presets/misc_stuff.lua
@@ -9,15 +9,17 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.misc_stuff"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-local map = single_pattern_builder(shape, pic.width, pic.height)
+local shape = b.picture(pic)
+local map = b.single_pattern(shape, pic.width, pic.height)
 
-map = change_map_gen_collision_tile(map, "water-tile", "grass-1")
-map = change_tile(map, false, "water")
+map = b.change_map_gen_collision_tile(map, "water-tile", "grass-1")
+map = b.change_tile(map, false, "water")
 
-map = scale(map, 5, 5)
+map = b.scale(map, 5, 5)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/mobius_strip.lua b/map_gen/presets/mobius_strip.lua
index f10ed7a8..db098307 100644
--- a/map_gen/presets/mobius_strip.lua
+++ b/map_gen/presets/mobius_strip.lua
@@ -7,29 +7,31 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local inner_circle = invert(circle_builder(48))
-local outer_circle = circle_builder(64)
-local square = invert(rectangle_builder(1000, 1000))
-square = rotate(square, degrees(45))
-square = translate(square, math.sqrt(2) * 500, 0)
+local b = require "map_gen.shared.builders"
 
-local circle = compound_and({inner_circle, outer_circle, square})
+local inner_circle = b.invert(b.circle(48))
+local outer_circle = b.circle(64)
+local square = b.invert(b.rectangle(1000, 1000))
+square = b.rotate(square, degrees(45))
+square = b.translate(square, math.sqrt(2) * 500, 0)
 
-local line1 = rectangle_builder(77, 16)
-line1 = rotate(line1, degrees(45))
-line1 = translate(line1, 66.5, 12.6875)
+local circle = b.all({inner_circle, outer_circle, square})
 
-local line2 = rectangle_builder(45, 16)
-local line2 = rotate(line2, degrees(-45))
-line2 = translate(line2, 55.5, -23.6875)
+local line1 = b.rectangle(77, 16)
+line1 = b.rotate(line1, degrees(45))
+line1 = b.translate(line1, 66.5, 12.6875)
 
---line2 =change_tile(line2, true, "water")
-local half = compound_or({line2, line1, circle})
+local line2 = b.rectangle(45, 16)
+local line2 = b.rotate(line2, degrees(-45))
+line2 = b.translate(line2, 55.5, -23.6875)
 
-half = translate(half, -79.1875, 0)
-local map = compound_or({half, flip_xy(half)})
+--line2 =b.change_tile(line2, true, "water")
+local half = b.any({line2, line1, circle})
 
-map = scale(map, 11, 11)
+half = b.translate(half, -79.1875, 0)
+local map = b.any({half, b.flip_xy(half)})
+
+map = b.scale(map, 11, 11)
 
 
 local function research_finished(event)
@@ -110,7 +112,7 @@ local function effect(x, y, world, tile)
     return tile
 end
 
-map = apply_effect(map, effect)
+map = b.apply_effect(map, effect)
 
 require "spawn_control"
 add_spawn("left", -88, -88)
diff --git a/map_gen/presets/mona_lisa.lua b/map_gen/presets/mona_lisa.lua
index b8a79e88..4b7a6652 100644
--- a/map_gen/presets/mona_lisa.lua
+++ b/map_gen/presets/mona_lisa.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.mona_lisa"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = translate(shape, 10, -96)
-shape = scale(shape,2,2)
---shape = rotate(shape, degrees(0))
+local shape = b.picture(pic)
+shape = b.translate(shape, 10, -96)
+shape = b.scale(shape,2,2)
+--shape = b.rotate(shape, degrees(0))
 
--- shape = change_tile(shape, false, "deepwater")
+-- shape = b.change_tile(shape, false, "deepwater")
 
 return shape
diff --git a/map_gen/presets/north_america.lua b/map_gen/presets/north_america.lua
index 79bf0d12..aec01f7f 100644
--- a/map_gen/presets/north_america.lua
+++ b/map_gen/presets/north_america.lua
@@ -5,17 +5,19 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.north_america"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
 -- this changes the size of the map
-map = scale(map, 2, 2)
+map = b.scale(map, 2, 2)
 
 -- this moves the map, effectively changing the spawn point.
- map = translate(map, 0, -200)
+ map = b.translate(map, 0, -200)
 
 -- this sets the tile outside the bounds of the map to deepwater, remove this and it will be void.
-map = change_tile(map, false, "deepwater")
+map = b.change_tile(map, false, "deepwater")
 
 return map
diff --git a/map_gen/presets/plus.lua b/map_gen/presets/plus.lua
index 1c10a4bb..0e0df19a 100644
--- a/map_gen/presets/plus.lua
+++ b/map_gen/presets/plus.lua
@@ -2,15 +2,17 @@
 require "map_gen.shared.generate_not_threaded"
 --require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.plus" --or whatever you called it in data->presets
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
-map = single_pattern_builder(map, pic.width-1, pic.height-1)
+map = b.single_pattern(map, pic.width-1, pic.height-1)
 
-map = translate(map, 86, 0)
+map = b.translate(map, 86, 0)
 
--- uncomment the line below to change the size of the map scale(x, y)
-map = scale(map, 1.5, 1.5)
+-- uncomment the line below to change the size of the map b.scale(x, y)
+map = b.scale(map, 1.5, 1.5)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/ring_of_balls.lua b/map_gen/presets/ring_of_balls.lua
index 600d4bb3..99979891 100644
--- a/map_gen/presets/ring_of_balls.lua
+++ b/map_gen/presets/ring_of_balls.lua
@@ -5,72 +5,74 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local ball = circle_builder(16)
+local b = require "map_gen.shared.builders"
 
-local arm = rectangle_builder(2, 13)
-local arm1 = translate(arm, 0, -19.5)
-local arm2 = translate(arm, 0, 22)
-local arm3 = rectangle_builder(2, 19)
-arm3 = rotate(arm3, degrees(-30))
-arm3 = translate(arm3, -12, 22)
+local ball = b.circle(16)
 
-ball = compound_or{ball, arm1, arm2, arm3}
-ball = translate(ball, 0, -28)
+local arm = b.rectangle(2, 13)
+local arm1 = b.translate(arm, 0, -19.5)
+local arm2 = b.translate(arm, 0, 22)
+local arm3 = b.rectangle(2, 19)
+arm3 = b.rotate(arm3, degrees(-30))
+arm3 = b.translate(arm3, -12, 22)
 
-local balls = compound_or{ball, rotate(ball, degrees(120)), rotate(ball, degrees(240))}
+ball = b.any{ball, arm1, arm2, arm3}
+ball = b.translate(ball, 0, -28)
 
-local small_circle = circle_builder(48)
-local big_circle = circle_builder(54)
-local ring = compound_and{big_circle, invert(small_circle)}
+local balls = b.any{ball, b.rotate(ball, degrees(120)), b.rotate(ball, degrees(240))}
 
-local big_ball = compound_or{balls, ring}
+local small_circle = b.circle(48)
+local big_circle = b.circle(54)
+local ring = b.all{big_circle, b.invert(small_circle)}
 
-local big_arm1 = rectangle_builder(6.75, 42.5)
-big_arm1 = translate(big_arm1, 0, -74.25)
---local big_arm2 = rectangle_builder(24, 242)
---big_arm2 = translate(big_arm2, 0, 174)
+local big_ball = b.any{balls, ring}
 
-big_ball = compound_or{big_ball, big_arm1, big_arm2}
+local big_arm1 = b.rectangle(6.75, 42.5)
+big_arm1 = b.translate(big_arm1, 0, -74.25)
+--local big_arm2 = b.rectangle(24, 242)
+--big_arm2 = b.translate(big_arm2, 0, 174)
 
-big_ball = rotate(big_ball, degrees(-90))
-big_ball = rotate(big_ball, math.atan2(54,210))
-big_ball = translate(big_ball, 210, -54)
+big_ball = b.any{big_ball, big_arm1, big_arm2}
+
+big_ball = b.rotate(big_ball, degrees(-90))
+big_ball = b.rotate(big_ball, math.atan2(54,210))
+big_ball = b.translate(big_ball, 210, -54)
 
 local big_balls = {}
 local count = 12
 local angle = 360 / count
 local offset = (180 / count) + 90
 for i = 0, count - 1 do
-    local s =rotate(big_ball, degrees(i * angle ))
+    local s =b.rotate(big_ball, degrees(i * angle ))
     table.insert(big_balls, s)
 end
 
-local big_balls = segment_pattern_builder(big_balls)
+local big_balls = b.segment_pattern(big_balls)
 
 
-local small_circle = circle_builder(304.5)
-local big_circle = circle_builder(316.5) --342.5625
-local ring = compound_and{big_circle, invert(small_circle)}
+local small_circle = b.circle(304.5)
+local big_circle = b.circle(316.5) --342.5625
+local ring = b.all{big_circle, b.invert(small_circle)}
 
-local map = compound_or{big_balls, ring}
+local map = b.any{big_balls, ring}
 
-local leg = rectangle_builder(32,480)
-local head = translate (oval_builder(32, 64), 0, -64)
-local body = translate (circle_builder(64), 0, 64)
+local leg = b.rectangle(32,480)
+local head = b.translate (b.oval(32, 64), 0, -64)
+local body = b.translate (b.circle(64), 0, 64)
 
 local count = 10
 local angle = 360 / count
 local list = { head, body }
 for i = 1, (count / 2) - 1 do
-    local shape = rotate(leg, degrees(i * angle))
+    local shape = b.rotate(leg, degrees(i * angle))
     table.insert( list, shape )
 end  
 
-local spider = compound_or(list) 
-spider = scale(spider,.75,.75)
+local spider = b.any(list) 
+spider = b.scale(spider,.75,.75)
 
---map = compound_or{map, spider}
-map = translate(map, -30, 201)
-map = scale(map, 12, 12)
+--map = b.any{map, spider}
+map = b.translate(map, -30, 201)
+map = b.scale(map, 12, 12)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/rings_and_boxes.lua b/map_gen/presets/rings_and_boxes.lua
index c4f0e670..5f50e5c5 100644
--- a/map_gen/presets/rings_and_boxes.lua
+++ b/map_gen/presets/rings_and_boxes.lua
@@ -5,35 +5,37 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local small_circle = circle_builder(16)
-local big_circle = circle_builder(18)
-local ring = compound_and{big_circle, invert(small_circle)}
+local b = require "map_gen.shared.builders"
 
-local box = rectangle_builder(10,10)
-box = translate(box, 16, -16)
-local line = rectangle_builder(36,1)
-line = translate(line, 0, -20.5)
-box = compound_or{box, line}
+local small_circle = b.circle(16)
+local big_circle = b.circle(18)
+local ring = b.all{big_circle, b.invert(small_circle)}
+
+local box = b.rectangle(10,10)
+box = b.translate(box, 16, -16)
+local line = b.rectangle(36,1)
+line = b.translate(line, 0, -20.5)
+box = b.any{box, line}
 
 local boxes = {}
 for i = 0, 3 do
-    local b = rotate(box, degrees(i*90))
+    local b = b.rotate(box, degrees(i*90))
     table.insert(boxes, b)
 end
 
-boxes = compound_or(boxes)
+boxes = b.any(boxes)
 
-local shape = compound_or{ring, boxes}
+local shape = b.any{ring, boxes}
 
 local shapes ={}
 local sf = 1.8
 local sf_total = 1
 for i = 1, 10 do
     sf_total = sf_total * sf
-    local s = scale(shape, sf_total, sf_total)
+    local s = b.scale(shape, sf_total, sf_total)
     table.insert(shapes, s)
 end
 
-local map = compound_or(shapes)
+local map = b.any(shapes)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/template.lua b/map_gen/presets/template.lua
index 2ca00edc..1d3a91be 100644
--- a/map_gen/presets/template.lua
+++ b/map_gen/presets/template.lua
@@ -5,20 +5,22 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.template"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
 -- this builds the map by duplicating the pic in every direction
--- map = single_pattern_builder(map, pic.width-1, pic.height-1)
+-- map = b.single_pattern(map, pic.width-1, pic.height-1)
 
 -- this changes the size of the map
---map = scale(map, 2, 2)
+--map = b.scale(map, 2, 2)
 
 -- this moves the map, effectively changing the spawn point.
---map = translate(map, 0, -200)
+--map = b.translate(map, 0, -200)
 
 -- this sets the tile outside the bounds of the map to deepwater, remove this and it will be void.
---map = change_tile(map, false, "deepwater")
+--map = b.change_tile(map, false, "deepwater")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/test.lua b/map_gen/presets/test.lua
index 20581afe..18590ba6 100644
--- a/map_gen/presets/test.lua
+++ b/map_gen/presets/test.lua
@@ -1,13 +1,18 @@
 require "map_gen.shared.generate"
 
-local land = rectangle_builder(32,16)
+local b = require "map_gen.shared.builders"
+
+local land = b.rectangle(32,16)
 
 
-local circle = circle_builder(4)
-local patch = resource_module_builder(circle, "iron-ore")
+local circle = b.circle(4)
+local patch = b.resource(b.circle(8), "iron-ore")
 
-local tree = spawn_entity(circle, "tree-01")
+local tree = b.entity(circle, "tree-01")
 
-local shape = builder_with_resource(land, patch)
+--[[ local shape = b.apply_entity(land, patch)
+shape = b.apply_entity(shape, tree) ]]
+
+local shape = apply_entities(land, {patch, tree})
 
 return shape
\ No newline at end of file
diff --git a/map_gen/presets/turkey.lua b/map_gen/presets/turkey.lua
index 0dc0b545..52e6674d 100644
--- a/map_gen/presets/turkey.lua
+++ b/map_gen/presets/turkey.lua
@@ -5,11 +5,13 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
-local pic = require "map_gen.data.presets.turkey"
-local pic = decompress(pic)
+local b = require "map_gen.shared.builders"
 
-local shape = picture_builder(pic)
-local shape = scale(shape, 4, 4)
-local shape = translate(shape, -300, 500)
+local pic = require "map_gen.data.presets.turkey"
+local pic = b.decompress(pic)
+
+local shape = b.picture(pic)
+local shape = b.scale(shape, 4, 4)
+local shape = b.translate(shape, -300, 500)
 
 return shape
diff --git a/map_gen/presets/venice.lua b/map_gen/presets/venice.lua
index cdbe31ac..f43ef3a7 100644
--- a/map_gen/presets/venice.lua
+++ b/map_gen/presets/venice.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 4 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.venice"
-local pic = decompress(pic)
-local map = picture_builder(pic)
+local pic = b.decompress(pic)
+local map = b.picture(pic)
 
-map = translate(map, 90, 190)
+map = b.translate(map, 90, 190)
 
-map = scale(map, 2, 2)
+map = b.scale(map, 2, 2)
 
-map = change_tile(map, false, "deepwater")
+map = b.change_tile(map, false, "deepwater")
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/void_gears.lua b/map_gen/presets/void_gears.lua
index 21f162c3..9ad91fa4 100644
--- a/map_gen/presets/void_gears.lua
+++ b/map_gen/presets/void_gears.lua
@@ -5,14 +5,16 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.void_gears"
-pic = decompress(pic)
+pic = b.decompress(pic)
 
-local shape = picture_builder(pic)
-shape = invert(shape)
+local shape = b.picture(pic)
+shape = b.invert(shape)
 
-local map = single_pattern_builder(shape, pic.width, pic.height)
-map = translate(map, -100, 120)
-map = scale(map, 2, 2)
+local map = b.single_pattern(shape, pic.width, pic.height)
+map = b.translate(map, -100, 120)
+map = b.scale(map, 2, 2)
 
 return map
\ No newline at end of file
diff --git a/map_gen/presets/web.lua b/map_gen/presets/web.lua
index f33bd6dd..bc4e21c1 100644
--- a/map_gen/presets/web.lua
+++ b/map_gen/presets/web.lua
@@ -5,49 +5,51 @@ map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_ge
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local stripe_thickness = 24
 local stripe_distance = 384
 
-local stripes = throttle_y(full_builder,stripe_thickness,stripe_distance)
-local joint = rectangle_builder(64)
-joint = rotate(joint,degrees(45))
-joint = translate(joint, 0, stripe_thickness / 2)
-local joints = single_y_pattern_builder(joint, stripe_distance)
+local stripes = b.throttle_y(b.full_shape,stripe_thickness,stripe_distance)
+local joint = b.rectangle(64)
+joint = b.rotate(joint,degrees(45))
+joint = b.translate(joint, 0, stripe_thickness / 2)
+local joints = b.single_y_pattern(joint, stripe_distance)
 
-stripes = compound_or{stripes, joints}
+stripes = b.any{stripes, joints}
 
 local lines = {}
 local count = 8
 local angle = 360 / count
 local offset = (180 / count) + 90
 for i = 0, count - 1 do
-    local line =rotate(stripes, degrees(i * angle + offset))
+    local line =b.rotate(stripes, degrees(i * angle + offset))
     table.insert(lines, line)
 end
 
-local web = segment_pattern_builder(lines)
-web = rotate(web, degrees(180 / count))
+local web = b.segment_pattern(lines)
+web = b.rotate(web, degrees(180 / count))
 
-local path = path_builder(stripe_thickness)
+local path = b.path(stripe_thickness)
 
-local leg = rectangle_builder(32,480)
-local head = translate (oval_builder(32, 64), 0, -64)
-local body = translate (circle_builder(64), 0, 64)
+local leg = b.rectangle(32,480)
+local head = b.translate (b.oval(32, 64), 0, -64)
+local body = b.translate (b.circle(64), 0, 64)
 
 local count = 10
 local angle = 360 / count
 local list = { head, body }
 for i = 1, (count / 2) - 1 do
-    local shape = rotate(leg, degrees(i * angle))
+    local shape = b.rotate(leg, degrees(i * angle))
     table.insert( list, shape )
 end  
 
-local spider = compound_or(list) 
-spider = scale(spider,2,2)
+local spider = b.any(list) 
+spider = b.scale(spider,2,2)
 
-local e = empty_builder
+local e = b.empty_shape
 local function s(r)
-    return rotate(spider, degrees(r))
+    return b.rotate(spider, degrees(r))
 end
 
 local pattern =
@@ -60,12 +62,12 @@ local pattern =
     {s(180), e     , e     , e     , e     , e     },
 }
 
-local spiders = grid_pattern_builder(pattern, 6, 6, 820, 820)
+local spiders = b.grid_pattern(pattern, 6, 6, 820, 820)
 
-local map = compound_or{ web, path, rotate(path, degrees(45)), spiders }
+local map = b.any{ web, path, b.rotate(path, degrees(45)), spiders }
 
-local start = circle_builder(150)
-map = choose(start, full_builder, map)
+local start = b.circle(150)
+map = b.choose(start, b.full_shape, map)
 
---map = scale(map, 0.5, 0.5)
+--map = b.scale(map, 0.5, 0.5)
 return map
\ No newline at end of file
diff --git a/map_gen/presets/women.lua b/map_gen/presets/women.lua
index 28f394c2..ab9e25c7 100644
--- a/map_gen/presets/women.lua
+++ b/map_gen/presets/women.lua
@@ -2,15 +2,17 @@
 --require "map_gen.shared.generate_not_threaded"
 require "map_gen.shared.generate"
 
+local b = require "map_gen.shared.builders"
+
 local pic = require "map_gen.data.presets.woman"
-local pic = decompress(pic)
-local shape = picture_builder(pic)
+local pic = b.decompress(pic)
+local shape = b.picture(pic)
 
-local map = single_pattern_overlap_builder(shape, pic.width - 50, pic.height - 120)
+local map = b.single_pattern_overlap(shape, pic.width - 50, pic.height - 120)
 
-map = translate(map, 135, -65)
---map = change_tile(map, false, "deepwater")
+map = b.translate(map, 135, -65)
+--map = b.change_tile(map, false, "deepwater")
 
---map = scale(map, 2, 2)
+--map = b.scale(map, 2, 2)
 
 return map
\ No newline at end of file
diff --git a/map_gen/shared/builders.lua b/map_gen/shared/builders.lua
index d57e5f06..0081700c 100644
--- a/map_gen/shared/builders.lua
+++ b/map_gen/shared/builders.lua
@@ -5,38 +5,41 @@ function degrees(angle)
     return angle * deg_to_rad
 end
 
-function get_tile(tile)
+local function add_entity(tile, entity)
     if type(tile) == "table" then
-        return tile.tile
-    else
-        return tile
+        if tile.entities then
+            table.insert(tile.entities, entity)
+        else
+            tile.entities = {entity}
+        end
+    elseif tile then
+        tile = {
+            tile = tile,
+            entities = {entity}
+        }
     end
+
+    return tile
 end
 
-function add_entity(tile, entity)
-    if tile.entities then
-        table.insert(tile.entities, entity)
-    else
-        tile.entities = {entity}
-    end
-end
+local Builders = {}
 
 -- shape builders
-function empty_builder()
+function Builders.empty_shape()
     return nil
 end
 
-function full_builder()
+function Builders.full_shape()
     return true
 end
 
-function tile_builder(tile)
+function Builders.tile(tile)
     return function()
         return tile
     end
 end
 
-function path_builder(thickness, optional_thickness_height)
+function Builders.path(thickness, optional_thickness_height)
     local width = thickness / 2
     local thickness2 = optional_thickness_height or thickness
     local height = thickness2 / 2
@@ -45,7 +48,7 @@ function path_builder(thickness, optional_thickness_height)
     end
 end
 
-function rectangle_builder(width, height)
+function Builders.rectangle(width, height)
     width = width / 2
     if height then
         height = height / 2
@@ -57,21 +60,21 @@ function rectangle_builder(width, height)
     end
 end
 
-function line_x_builder(thickness)
+function Builders.line_x(thickness)
     thickness = thickness / 2
     return function(x, y)
         return y > -thickness and y <= thickness
     end
 end
 
-function line_y_builder(thickness)
+function Builders.line_y(thickness)
     thickness = thickness / 2
     return function(x, y)
         return x > -thickness and x <= thickness
     end
 end
 
-function square_diamond_builder(size)
+function Builders.square_diamond(size)
     size = size / 2
     return function(x, y)
         return math.abs(x) + math.abs(y) <= size
@@ -79,7 +82,7 @@ function square_diamond_builder(size)
 end
 
 local rot = math.sqrt(2) / 2 -- 45 degree rotation.
-function rectangle_diamond_builder(width, height)
+function Builders.rectangle_diamond(width, height)
     width = width / 2
     height = height / 2
     return function(x, y)
@@ -89,14 +92,14 @@ function rectangle_diamond_builder(width, height)
     end
 end
 
-function circle_builder(radius)
+function Builders.circle(radius)
     local rr = radius * radius
     return function(x, y)
         return x * x + y * y < rr
     end
 end
 
-function oval_builder(x_radius, y_radius)
+function Builders.oval(x_radius, y_radius)
     local x_rr = x_radius * x_radius
     local y_rr = y_radius * y_radius
     return function(x, y)
@@ -104,7 +107,7 @@ function oval_builder(x_radius, y_radius)
     end
 end
 
-function sine_fill_builder(width, height)
+function Builders.sine_fill(width, height)
     width_inv = tau / width
     height_inv = -2 / height
     return function(x, y)
@@ -154,7 +157,7 @@ local tile_map = {
     [33] = "water"
 }
 
-function decompress(pic)
+function Builders.decompress(pic)
     local data = pic.data
     local width = pic.width
     local height = pic.height
@@ -180,7 +183,7 @@ function decompress(pic)
     return {width = width, height = height, data = uncompressed}
 end
 
-function picture_builder(pic)
+function Builders.picture(pic)
     local data = pic.data
     local width = pic.width
     local height = pic.height
@@ -203,53 +206,52 @@ function picture_builder(pic)
 end
 
 -- transforms and shape helpers
-function translate(builder, x_offset, y_offset)
+function Builders.translate(shape, x_offset, y_offset)
     return function(x, y, world)
-        return builder(x - x_offset, y - y_offset, world)
+        return shape(x - x_offset, y - y_offset, world)
     end
 end
 
-function scale(builder, x_scale, y_scale)
+function Builders.scale(shape, x_scale, y_scale)
     x_scale = 1 / x_scale
     y_scale = 1 / y_scale
     return function(x, y, world)
-        return builder(x * x_scale, y * y_scale, world)
+        return shape(x * x_scale, y * y_scale, world)
     end
 end
 
-function rotate(builder, angle)
+function Builders.rotate(shape, angle)
     local qx = math.cos(angle)
     local qy = math.sin(angle)
     return function(x, y, world)
         local rot_x = qx * x - qy * y
         local rot_y = qy * x + qx * y
-        return builder(rot_x, rot_y, world)
+        return shape(rot_x, rot_y, world)
     end
 end
 
-function flip_x(builder)
+function Builders.flip_x(shape)
     return function(x, y, world)
-        return builder(-x, y, world)
+        return shape(-x, y, world)
     end
 end
 
-function flip_y(builder)
+function Builders.flip_y(shape)
     return function(x, y, world)
-        return builder(x, -y, world)
+        return shape(x, -y, world)
     end
 end
 
-function flip_xy(builder)
+function Builders.flip_xy(shape)
     return function(x, y, world)
-        return builder(-x, -y, world)
+        return shape(-x, -y, world)
     end
 end
 
--- For resource_module_builder it will return the first success.
-function compound_or(builders)
+function Builders.any(shapes)
     return function(x, y, world)
-        for _, v in ipairs(builders) do
-            local tile = v(x, y, world)
+        for _, s in ipairs(shapes) do
+            local tile = s(x, y, world)
             if tile then
                 return tile
             end
@@ -258,12 +260,11 @@ function compound_or(builders)
     end
 end
 
--- Wont work correctly with resource_module_builder becasues I don't know which one to return.
-function compound_and(builders)
+function Builders.all(shapes)
     return function(x, y, world)
         local tile
-        for _, v in ipairs(builders) do
-            tile = v(x, y, world)
+        for _, s in ipairs(shapes) do
+            tile = s(x, y, world)
             if not tile then
                 return false
             end
@@ -272,64 +273,54 @@ function compound_and(builders)
     end
 end
 
-function invert(builder)
+function Builders.invert(shape)
     return function(x, y, world)
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
         return not tile
     end
 end
 
-function throttle_x(builder, x_in, x_size)
+function Builders.throttle_x(shape, x_in, x_size)
     return function(x, y, world)
         if x % x_size < x_in then
-            return builder(x, y, world)
+            return shape(x, y, world)
         else
             return false
         end
     end
 end
 
-function throttle_y(builder, y_in, y_size)
+function Builders.throttle_y(shape, y_in, y_size)
     return function(x, y, world)
         if y % y_size < y_in then
-            return builder(x, y, world)
+            return shape(x, y, world)
         else
             return false
         end
     end
 end
 
-function throttle_xy(builder, x_in, x_size, y_in, y_size)
+function Builders.throttle_xy(shape, x_in, x_size, y_in, y_size)
     return function(x, y, world)
         if x % x_size < x_in and y % y_size < y_in then
-            return builder(x, y, world)
+            return shape(x, y, world)
         else
             return false
         end
     end
 end
 
-function throttle_xy(builder, x_in, x_size, y_in, y_size)
-    return function(x, y, world)
-        if x % x_size < x_in and y % y_size < y_in then
-            return builder(x, y, world)
-        else
-            return false
-        end
-    end
-end
-
-function throttle_world_xy(builder, x_in, x_size, y_in, y_size)
+function Builders.throttle_world_xy(shape, x_in, x_size, y_in, y_size)
     return function(x, y, world)
         if world.x % x_size < x_in and world.y % y_size < y_in then
-            return builder(x, y, world)
+            return shape(x, y, world)
         else
             return false
         end
     end
 end
 
-function choose(condition, true_shape, false_shape)
+function Builders.choose(condition, true_shape, false_shape)
     return function(x, y, world)
         if condition(x, y, world) then
             return true_shape(x, y, world)
@@ -339,13 +330,13 @@ function choose(condition, true_shape, false_shape)
     end
 end
 
-function shape_or_else(shape, else_shape)
+function Builders.if_else(shape, else_shape)
     return function(x, y, world)
         return shape(x, y, world) or else_shape(x, y, world)
     end
 end
 
-function linear_grow(shape, size)
+function Builders.linear_grow(shape, size)
     local half_size = size / 2
     return function(x, y, world)
         local t = math.ceil((y / size) + 0.5)
@@ -360,7 +351,7 @@ function linear_grow(shape, size)
     end
 end
 
-function grow(in_shape, out_shape, size, offset)
+function Builders.grow(in_shape, out_shape, size, offset)
     local half_size = size / 2
     return function(x, y, world)
         local tx = math.ceil(math.abs(x) / half_size)
@@ -385,7 +376,7 @@ function grow(in_shape, out_shape, size, offset)
     end
 end
 
-function project(shape, size, r)
+function Builders.project(shape, size, r)
     local ln_r = math.log(r)
     local r2 = 1 / (r - 1)
     local a = 1 / size
@@ -407,7 +398,7 @@ function project(shape, size, r)
     end
 end
 
-function project_overlap(shape, size, r)
+function Builders.project_overlap(shape, size, r)
     local ln_r = math.log(r)
     local r2 = 1 / (r - 1)
     local a = 1 / size
@@ -461,12 +452,12 @@ end
 
 -- ore generation.
 -- builder is the shape of the ore patch.
-function resource_module_builder(builder, resource_type, amount_function)
+function Builders.resource(shape, resource_type, amount_function)
     amount_function = amount_function or function(a, b)
             return 404
         end
     return function(x, y, world)
-        if builder(x, y, world) then
+        if shape(x, y, world) then
             return {
                 name = resource_type,
                 position = {world.x, world.y},
@@ -476,20 +467,35 @@ function resource_module_builder(builder, resource_type, amount_function)
     end
 end
 
-function builder_with_resource(land_builder, resource_module)
+function Builders.apply_entity(shape, entity_shape)
     return function(x, y, world)
-        local tile = land_builder(x, y, world)
-        if tile then
-            local entity = resource_module(x, y, world)
-            if entity then
-                if type(tile) == "table" then
-                    add_entity(tile, entity)
-                else
-                    tile = {
-                        tile = tile,
-                        entities = {entity}
-                    }
-                end
+        local tile = shape(x, y, world)
+
+        if not tile then
+            return false
+        end
+
+        local e = entity_shape(x, y, world)
+        if e then
+            tile = add_entity(tile, e)
+        end
+
+        return tile
+    end
+end
+
+function Builders.apply_entities(shape, entity_shapes)
+    return function(x, y, world)
+        local tile = shape(x, y, world)
+
+        if not tile then
+            return false
+        end
+
+        for _, es in ipairs(entity_shapes) do
+            local e = es(x, y, world)
+            if e then
+                tile = add_entity(tile, e)
             end
         end
 
@@ -498,8 +504,8 @@ function builder_with_resource(land_builder, resource_module)
 end
 
 -- pattern builders.
-function single_pattern_builder(shape, width, height)
-    shape = shape or empty_builder
+function Builders.single_pattern(shape, width, height)
+    shape = shape or Builder.empty_shape
     local half_width = width / 2
     local half_height
     if height then
@@ -516,8 +522,8 @@ function single_pattern_builder(shape, width, height)
     end
 end
 
-function single_pattern_overlap_builder(shape, width, height)
-    shape = shape or empty_builder
+function Builders.single_pattern_overlap(shape, width, height)
+    shape = shape or Builder.empty_shape
     local half_width = width / 2
     local half_height
     if height then
@@ -536,8 +542,8 @@ function single_pattern_overlap_builder(shape, width, height)
     end
 end
 
-function single_x_pattern_builder(shape, width)
-    shape = shape or empty_builder
+function Builders.single_x_pattern(shape, width)
+    shape = shape or Builder.empty_shape
     local half_width = width / 2
 
     return function(x, y, world)
@@ -547,8 +553,8 @@ function single_x_pattern_builder(shape, width)
     end
 end
 
-function single_y_pattern_builder(shape, height)
-    shape = shape or empty_builder
+function Builders.single_y_pattern(shape, height)
+    shape = shape or Builder.empty_shape
     local half_height = height / 2
 
     return function(x, y, world)
@@ -558,7 +564,7 @@ function single_y_pattern_builder(shape, height)
     end
 end
 
-function grid_pattern_builder(pattern, columns, rows, width, height)
+function Builders.grid_pattern(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -572,12 +578,12 @@ function grid_pattern_builder(pattern, columns, rows, width, height)
         local col_pos = math.floor(x / width + 0.5)
         local col_i = col_pos % columns + 1
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
         return shape(x2, y2, world)
     end
 end
 
-function grid_pattern_overlap_builder(pattern, columns, rows, width, height)
+function Builders.grid_pattern_overlap(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -591,7 +597,7 @@ function grid_pattern_overlap_builder(pattern, columns, rows, width, height)
         local col_pos = math.floor(x / width + 0.5)
         local col_i = col_pos % columns + 1
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
 
         local tile = shape(x2, y2, world)
         if tile then
@@ -600,14 +606,14 @@ function grid_pattern_overlap_builder(pattern, columns, rows, width, height)
 
         -- edges
         local col_i_left = (col_pos - 1) % columns + 1
-        shape = row[col_i_left] or empty_builder
+        shape = row[col_i_left] or Builder.empty_shape
         tile = shape(x2 + width, y2, world)
         if tile then
             return tile
         end
 
         local col_i_right = (col_pos + 1) % columns + 1
-        shape = row[col_i_right] or empty_builder
+        shape = row[col_i_right] or Builder.empty_shape
         tile = shape(x2 - width, y2, world)
         if tile then
             return tile
@@ -615,7 +621,7 @@ function grid_pattern_overlap_builder(pattern, columns, rows, width, height)
 
         local row_i_up = (row_pos - 1) % rows + 1
         local row_up = pattern[row_i_up] or {}
-        shape = row_up[col_i] or empty_builder
+        shape = row_up[col_i] or Builder.empty_shape
         tile = shape(x2, y2 + height, world)
         if tile then
             return tile
@@ -623,12 +629,12 @@ function grid_pattern_overlap_builder(pattern, columns, rows, width, height)
 
         local row_i_down = (row_pos + 1) % rows + 1
         local row_down = pattern[row_i_down] or {}
-        shape = row_down[col_i] or empty_builder
+        shape = row_down[col_i] or Builder.empty_shape
         return shape(x2, y2 - height, world)
     end
 end
 
-function grid_pattern_full_overlap_builder(pattern, columns, rows, width, height)
+function Builders.grid_pattern_full_overlap(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -651,71 +657,71 @@ function grid_pattern_full_overlap_builder(pattern, columns, rows, width, height
         local col_i_right = (col_pos + 1) % columns + 1
 
         -- start from top left, move left to right then down
-        local shape = row_up[col_i_left] or empty_builder
+        local shape = row_up[col_i_left] or Builder.empty_shape
         local tile = shape(x2 + width, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row_up[col_i] or empty_builder
+        shape = row_up[col_i] or Builder.empty_shape
         tile = shape(x2, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row_up[col_i_right] or empty_builder
+        shape = row_up[col_i_right] or Builder.empty_shape
         tile = shape(x2 - width, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row[col_i_left] or empty_builder
+        shape = row[col_i_left] or Builder.empty_shape
         tile = shape(x2 + width, y2, world)
         if tile then
             return tile
         end
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
         tile = shape(x2, y2, world)
         if tile then
             return tile
         end
 
-        shape = row[col_i_right] or empty_builder
+        shape = row[col_i_right] or Builder.empty_shape
         tile = shape(x2 - width, y2, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i_left] or empty_builder
+        shape = row_down[col_i_left] or Builder.empty_shape
         tile = shape(x2 + width, y2 - height, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i] or empty_builder
+        shape = row_down[col_i] or Builder.empty_shape
         tile = shape(x2, y2 - height, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i_right] or empty_builder
+        shape = row_down[col_i_right] or Builder.empty_shape
         return shape(x2 - width, y2 - height, world)
     end
 end
 
-function segment_pattern_builder(pattern)
+function Builders.segment_pattern(pattern)
     local count = #pattern
 
     return function(x, y, world)
         local angle = math.atan2(-y, x)
         local index = math.floor(angle / tau * count) % count + 1
-        local shape = pattern[index] or empty_builder
+        local shape = pattern[index] or Builder.empty_shape
         return shape(x, y, world)
     end
 end
 
-function pyramid_builder(pattern, columns, rows, width, height)
+function Builders.pyramid_pattern(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -737,12 +743,12 @@ function pyramid_builder(pattern, columns, rows, width, height)
             return false
         end
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
         return shape(x2, y2, world)
     end
 end
 
-function pyramid_inner_overlap_builder(pattern, columns, rows, width, height)
+function Builders.pyramid_pattern_inner_overlap(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -794,60 +800,60 @@ function pyramid_inner_overlap_builder(pattern, columns, rows, width, height)
         local col_i_right2 = (col_pos + 0) % columns + 1
 
         -- start from top left, move left to right then down
-        local shape = row_up[col_i_left] or empty_builder
+        local shape = row_up[col_i_left] or Builder.empty_shape
         local tile = shape(x_even + width, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row_up[col_i_odd] or empty_builder
+        shape = row_up[col_i_odd] or Builder.empty_shape
         tile = shape(x_odd, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row_up[col_i_right] or empty_builder
+        shape = row_up[col_i_right] or Builder.empty_shape
         tile = shape(x_even - width, y2 + height, world)
         if tile then
             return tile
         end
 
-        shape = row[col_i_left] or empty_builder
+        shape = row[col_i_left] or Builder.empty_shape
         tile = shape(x_even + width, y2, world)
         if tile then
             return tile
         end
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
         tile = shape(x_even, y2, world)
         if tile then
             return tile
         end
 
-        shape = row[col_i_right] or empty_builder
+        shape = row[col_i_right] or Builder.empty_shape
         tile = shape(x_even - width, y2, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i_left] or empty_builder
+        shape = row_down[col_i_left] or Builder.empty_shape
         tile = shape(x_even + width, y2 - height, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i_odd] or empty_builder
+        shape = row_down[col_i_odd] or Builder.empty_shape
         tile = shape(x_odd, y2 - height, world)
         if tile then
             return tile
         end
 
-        shape = row_down[col_i_right] or empty_builder
+        shape = row_down[col_i_right] or Builder.empty_shape
         return shape(x_even - width, y2 - height, world)
     end
 end
 
-function grid_pattern_offset_builder(pattern, columns, rows, width, height)
+function Builders.grid_pattern_offset(pattern, columns, rows, width, height)
     local half_width = width / 2
     local half_height = height / 2
 
@@ -864,15 +870,15 @@ function grid_pattern_offset_builder(pattern, columns, rows, width, height)
         local y2 = y2 + height * math.floor((row_pos + 1) / rows)
         local x2 = x2 + width * math.floor((col_pos + 1) / columns)
 
-        local shape = row[col_i] or empty_builder
+        local shape = row[col_i] or Builder.empty_shape
         return shape(x2, y2, world)
     end
 end
 
 -- tile converters
-function change_tile(builder, old_tile, new_tile)
+function Builders.change_tile(shape, old_tile, new_tile)
     return function(x, y, world)
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
 
         if type(tile) == "table" then
             if tile.tile == old_tile then
@@ -888,9 +894,9 @@ function change_tile(builder, old_tile, new_tile)
     end
 end
 
-function change_collision_tile(builder, collides, new_tile)
+function Builders.change_collision_tile(shape, collides, new_tile)
     return function(x, y, world)
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
 
         if type(tile) == "table" then
             if tile.tile.collides_with(collides) then
@@ -908,7 +914,7 @@ function change_collision_tile(builder, collides, new_tile)
 end
 
 -- only changes tiles made by the factorio map generator.
-function change_map_gen_tile(builder, old_tile, new_tile)
+function Builders.change_map_gen_tile(shape, old_tile, new_tile)
     return function(x, y, world)
         local function handle_tile(tile)
             if type(tile) == "boolean" and tile then
@@ -920,7 +926,7 @@ function change_map_gen_tile(builder, old_tile, new_tile)
             return tile
         end
 
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
 
         if type(tile) == "table" then
             tile.tile = handle_tile(tile.tile)
@@ -933,7 +939,7 @@ function change_map_gen_tile(builder, old_tile, new_tile)
 end
 
 -- only changes tiles made by the factorio map generator.
-function change_map_gen_collision_tile(builder, collides, new_tile)
+function Builders.change_map_gen_collision_tile(shape, collides, new_tile)
     return function(x, y, world)
         local function handle_tile(tile)
             if type(tile) == "boolean" and tile then
@@ -945,7 +951,7 @@ function change_map_gen_collision_tile(builder, collides, new_tile)
             return tile
         end
 
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
 
         if type(tile) == "table" then
             tile.tile = handle_tile(tile.tile)
@@ -964,7 +970,7 @@ local water_tiles = {
     ["deepwater-green"] = true
 }
 
-function spawn_fish(builder, spawn_rate)
+function Builders.fish(shape, spawn_rate)
     return function(x, y, world)
         local function handle_tile(tile)
             if type(tile) == "string" then
@@ -978,7 +984,7 @@ function spawn_fish(builder, spawn_rate)
             end
         end
 
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
 
         if type(tile) == "table" then
             local entity = handle_tile(tile.tile)
@@ -999,30 +1005,31 @@ function spawn_fish(builder, spawn_rate)
     end
 end
 
---todo change to entiy_module_builder
-function spawn_entity(builder, name)
+function Builders.entity(shape, name)
     return function(x, y, world)
-        if builder(x, y, world) then
+        if shape(x, y, world) then
             return {name = name, position = {world.x, world.y}}
         end
     end
 end
 
-function apply_effect(builder, func)
+function Builders.apply_effect(shape, func)
     return function(x, y, world)
-        local tile = builder(x, y, world)
+        local tile = shape(x, y, world)
         return func(x, y, world, tile)
     end
 end
 
-function manhattan_ore_value(base, mult)
+function Builders.manhattan_value(base, mult)
     return function(x, y)
         return mult * (math.abs(x) + math.abs(y)) + base
     end
 end
 
-function euclidean_ore_value(base, mult)
+function Builders.euclidean_value(base, mult)
     return function(x, y)
         return mult * math.sqrt(x * x + y * y) + base
     end
 end
+
+return Builders