new maps

map_gen/combined/meteor_strike.lua

@@ -0,0 +1,174 @@
+require "locale.gen_shared.perlin_noise"
+local Thread = require "locale.utils.Thread"
+
+local block_size = 1 -- in tiles
+local start_size = 64 -- in blocks
+local strike_time = 1 -- in ticks
+
+-- dud blocks don't spawn meteors, with a block_weight = 1 and dud weight = 3, every 3 out of 4 blocks will be a dud block
+local block_weight = 1
+local dud_weight  =  0
+local min_blocks_in_list = 10 -- no dud meteors if the number of blocks in the list is less than or equal to this
+
+global.blocks = nil
+global.used_blocks = nil
+global.strike_time = strike_time
+global.weight_count = 0
+
+local half_start_size = (start_size * block_size) / 2
+local total_weight = block_weight + dud_weight
+
+local function init_blocks()
+    local blocks = {}
+    local used_blocks = {}
+    local half = start_size / 2    
+    for i = -half, half - 1 do
+        table.insert(blocks,{x = i, y = -half - 1})
+        used_blocks[i .. "," .. (-half - 1)] = true 
+        table.insert(blocks,{x = i, y = half})
+        used_blocks[i .. "," .. half] = true 
+        table.insert(blocks,{x = -half - 1, y = i})
+        used_blocks[(-half - 1) .. "," .. i] = true 
+        table.insert(blocks,{x = half, y = i})      
+        used_blocks[half .. "," .. i] = true 
+
+        for j = -half, half -1 do        
+            used_blocks[i .. "," .. j] = true            
+        end 
+    end
+
+   
+
+    global.blocks = blocks
+    global.used_blocks = used_blocks
+end
+
+local function get_resource(x,y)
+    local value = perlin:noise(x /16 , y / 16)
+    value = value + 1
+    value = value * 500
+
+    local name = ""
+
+    if value < 450 then
+        return nil        
+    elseif value < 550 then
+        name = "iron-ore"        
+    elseif value < 650 then
+        name = "copper-ore"        
+    elseif value < 750 then
+        name = "coal"
+    elseif value < 850 then
+        name = "stone"    
+    else 
+        return nil
+    end
+
+    value = perlin:noise(y /64 , x / 64)
+    value = value + 1
+    value = value * 500
+
+    return {name=name,position={x,y}, amount = value}
+end
+
+function run_combined_module(event)
+
+    if not global.blocks then
+        init_blocks()
+    end
+
+    local area = event.area
+    local surface = event.surface
+    local top_x = area.left_top.x
+    local top_y = area.left_top.y   
+    
+    local tiles = {}
+    local entities = {}    
+
+    for y = top_y, top_y + 31 do
+        for x = top_x, top_x + 31 do  
+
+            if -x > half_start_size or x >= half_start_size or -y > half_start_size or y >= half_start_size then
+                table.insert(tiles, {name="out-of-map", position = {x, y}})
+            end
+
+            local e = get_resource(x,y)
+            if e then
+                table.insert(entities, e)
+            end
+        end
+    end
+    
+    surface.set_tiles(tiles, false)
+
+    for _, e in ipairs(entities) do
+        if surface.can_place_entity(e) then
+          surface.create_entity(e)
+        end
+    end
+end
+
+local function get_block()
+    local blocks = global.blocks
+    local count = global.weight_count
+    while count >= block_weight and count < total_weight and #blocks > min_blocks_in_list do
+        local index = math.random(#blocks)
+        table.remove(blocks, index) 
+        count = count + 1
+    end
+
+    if count < block_weight then
+        count = count + 1
+    end
+
+    if count == total_weight then        
+        global.weight_count = 0
+    else
+        global.weight_count = count
+    end
+
+    local index = math.random(#blocks)
+    return table.remove(blocks, index)   
+end
+
+local function do_strike()              
+    local block = get_block()  
+
+    function add(x,y)
+        local key = x .. "," .. y
+        if not global.used_blocks[key] then
+            table.insert(global.blocks, {x = x, y = y})
+            global.used_blocks[key] = true            
+        end
+    end
+
+    add(block.x, block.y - 1)
+    add(block.x + 1, block.y)
+    add(block.x, block.y + 1)
+    add(block.x - 1, block.y)     
+
+    local tiles = {}
+    local bx = block.x * block_size
+    local by = block.y * block_size    
+
+    for x = bx, bx + block_size - 1 do
+        for y = by, by + block_size - 1 do
+            table.insert(tiles, {name = "dry-dirt", position = {x, y}})
+        end
+    end
+    local surface = game.surfaces[1]
+    surface.set_tiles(tiles, false)
+
+    game.forces.player.chart(surface, {{bx, by}, {bx+block_size, by+block_size}})
+end
+
+local function on_tick()    
+    if global.strike_time == 0 then
+        do_strike()
+        global.strike_time = strike_time
+    else        
+        global.strike_time = global.strike_time - 1
+    end
+end
+
+Event.register(defines.events.on_tick, on_tick)

map_gen/combined/meteor_strike_data.lua

@@ -0,0 +1,23 @@
+local data =
+{
+    {
+        weight = 1
+        thresholds =
+        {
+            {value = 400, name = nil},
+            {value = 500, name = "iron-ore"},
+            {value = 600, name = "copper-ore"},
+            {value = 700, name = "coal"},
+            {value = 800, name = "stone"},
+        }
+    }
+}
+
+
+local function process_data()
+
+
+end
+
+process_data()
+return data

map_gen/presets/dna.lua

@@ -0,0 +1,119 @@
+--[[
+This map uses custom ore gen. When generating the map, under the resource settings tab use Size = 'None' for all resources.
+]]
+
+map_gen_decoratives = false -- Generate our own decoratives
+map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_gen_threaded, higher numbers will generate map quicker but cause more lag.
+
+-- Recommend to use generate, but generate_not_threaded may be useful for testing / debugging.
+--require "map_gen.shared.generate_not_threaded"
+require "map_gen.shared.generate"
+
+local ball_r = 16
+local big_circle = circle_builder(ball_r)
+local small_circle = circle_builder(0.6 * ball_r)
+
+local ribben = {big_circle}
+local count = 8
+local angle = math.pi / count
+local offset_x = 32
+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)
+    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)
+    table.insert(ribben, c)
+end
+ribben = compound_or(ribben)
+
+local function value(mult,base)
+    return function(a, b)
+        return mult * (math.abs(a) + math.abs(b)) + base
+    end
+end
+
+local oil_shape = circle_builder(0.16 * ball_r)
+oil_shape = throttle_xy(oil_shape, 1, 2, 1, 2)
+
+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))
+}
+
+local lines = {}
+local lines_circle = circle_builder(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 c = lines_circle
+    c = builder_with_resource(c, resources[i])
+    local c = translate(c, x, 0)    
+
+    table.insert(lines, c)
+    table.insert(lines, l)
+end
+lines = compound_or(lines)
+
+local dna = compound_or{lines, ribben, flip_y(ribben)}
+
+
+
+
+
+local widith = offset_x * count
+dna = translate(dna, -widith/ 2, 0)
+local map = single_x_pattern_builder(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}
+ ]]
+
+map = translate(map, -widith/2, 0)
+map = rotate(map, degrees(45))
+
+local start_circle =  circle_builder(0.3 * ball_r)
+
+local iron = builder_with_resource(start_circle, resource_module_builder(scale(start_circle,0.5,0.5), "iron-ore", value(0, 700)))
+local copper = builder_with_resource(start_circle, resource_module_builder(scale(start_circle,0.5,0.5), "copper-ore", value(0, 500)))
+local stone = builder_with_resource(start_circle, resource_module_builder(scale(start_circle,0.5,0.5), "stone", value(0, 250)))
+local oil = builder_with_resource(start_circle, resource_module_builder(scale(start_circle,0.1,0.1), "crude-oil", value(0, 40000)))
+local coal = builder_with_resource(start_circle, resource_module_builder(scale(start_circle,0.5,0.5), "coal", value(0, 800)))
+
+local start = compound_or
+{
+    translate(iron, 0, -9),
+    translate(copper, 0, 9),
+    translate(stone, -9, 0),
+    translate(oil, 9, 9),
+    translate(coal, 9, 0),
+    big_circle
+}
+
+map = choose(big_circle, start, map)
+
+map = scale(map, 6, 6)
+return map
+

map_gen/presets/ring_of_balls.lua

@@ -0,0 +1,76 @@
+map_gen_decoratives = false -- Generate our own decoratives
+map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_gen_threaded, higher numbers will generate map quicker but cause more lag.
+
+-- Recommend to use generate, but generate_not_threaded may be useful for testing / debugging.
+--require "map_gen.shared.generate_not_threaded"
+require "map_gen.shared.generate"
+
+local ball = circle_builder(16)
+
+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)
+
+ball = compound_or{ball, arm1, arm2, arm3}
+ball = translate(ball, 0, -28)
+
+local balls = compound_or{ball, rotate(ball, degrees(120)), rotate(ball, degrees(240))}
+
+local small_circle = circle_builder(48)
+local big_circle = circle_builder(54)
+local ring = compound_and{big_circle, invert(small_circle)}
+
+local big_ball = compound_or{balls, ring}
+
+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)
+
+big_ball = compound_or{big_ball, big_arm1, big_arm2}
+
+big_ball = rotate(big_ball, degrees(-90))
+big_ball = rotate(big_ball, math.atan2(54,210))
+big_ball = 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 ))
+    table.insert(big_balls, s)
+end
+
+local big_balls = segment_pattern_builder(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 map = compound_or{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 count = 10
+local angle = 360 / count
+local list = { head, body }
+for i = 1, (count / 2) - 1 do
+    local shape = rotate(leg, degrees(i * angle))
+    table.insert( list, shape )
+end  
+
+local spider = compound_or(list) 
+spider = scale(spider,.75,.75)
+
+--map = compound_or{map, spider}
+map = translate(map, -30, 201)
+map = scale(map, 12, 12)
+
+return map

map_gen/presets/rings_and_boxes.lua

@@ -0,0 +1,39 @@
+map_gen_decoratives = false -- Generate our own decoratives
+map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_gen_threaded, higher numbers will generate map quicker but cause more lag.
+
+-- Recommend to use generate, but generate_not_threaded may be useful for testing / debugging.
+--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 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 boxes = {}
+for i = 0, 3 do
+    local b = rotate(box, degrees(i*90))
+    table.insert(boxes, b)
+end
+
+boxes = compound_or(boxes)
+
+local shape = compound_or{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)
+    table.insert(shapes, s)
+end
+
+local map = compound_or(shapes)
+
+return map

map_gen/presets/web.lua

@@ -0,0 +1,71 @@
+map_gen_decoratives = false -- Generate our own decoratives
+map_gen_rows_per_tick = 8 -- Inclusive integer between 1 and 32. Used for map_gen_threaded, higher numbers will generate map quicker but cause more lag.
+
+-- Recommend to use generate, but generate_not_threaded may be useful for testing / debugging.
+--require "map_gen.shared.generate_not_threaded"
+require "map_gen.shared.generate"
+
+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)
+
+stripes = compound_or{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))
+    table.insert(lines, line)
+end
+
+local web = segment_pattern_builder(lines)
+web = rotate(web, degrees(180 / count))
+
+local path = path_builder(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 count = 10
+local angle = 360 / count
+local list = { head, body }
+for i = 1, (count / 2) - 1 do
+    local shape = rotate(leg, degrees(i * angle))
+    table.insert( list, shape )
+end  
+
+local spider = compound_or(list) 
+spider = scale(spider,2,2)
+
+local e = empty_builder
+local function s(r)
+    return rotate(spider, degrees(r))
+end
+
+local pattern =
+{
+    {e     , s(90) , e     , s(0) , e      , s(270)},
+    {s(0)  , e     , e     , e     , e     , e     },
+    {e     , e     , s(45) , e     , s(315), e     },
+    {s(90) , e     , e     , e     , e     , e     },
+    {e     , e     , s(135), e     , s(225), e     },
+    {s(180), e     , e     , e     , e     , e     },
+}
+
+local spiders = grid_pattern_builder(pattern, 6, 6, 820, 820)
+
+local map = compound_or{ web, path, rotate(path, degrees(45)), spiders }
+
+local start = circle_builder(150)
+map = choose(start, full_builder, map)
+
+--map = scale(map, 0.5, 0.5)
+return map

map_layout.lua

@@ -5,7 +5,6 @@ If you want to add your own module, just add it to the others
 in this file and your run_*type*_module(event) function will be called.
 --]]
 
-
 --combined--
 --require "map_gen.combined.island_resort"
 --require "map_gen.combined.red_planet_v2"
@@ -13,27 +12,28 @@ in this file and your run_*type*_module(event) function will be called.
 --require "map_gen.combined.dimensions"
 --require "map_gen.combined.dagobah_swamp"
 --require "map_gen.combined.UK"
+--require "map_gen.combined.meteor_strike" --unfinished
 
---grilledham's map gen
--- Need to copy the file you want from the _locale folder to this one for it to be included
--- only get what you need, otherwise the save file is too big!
-
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.template"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.mobius_strip"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.antfarm"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.creation_of_adam"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.manhattan"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.mona_lisa"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.connected_dots"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.cage"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.maori"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.goat"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.biome_test"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.GoT"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.turkey"
---require "locale.grilledham_map_gen.presets.UK"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.north_america"
---MAP_GEN = require "map_gen.combined.grilledham_map_gen.presets.lines_and_balls"
+--presets--
+--MAP_GEN = require "map_gen.presets.template"
+--MAP_GEN = require "map_gen.presets.web" --unfinished
+--MAP_GEN = require "map_gen.presets.rings_and_boxes" --unfinished
+--MAP_GEN = require "map_gen.presets.ring_of_balls" --unfinished
+MAP_GEN = require "map_gen.presets.dna"
+--MAP_GEN = require "map_gen.presets.lines_and_balls"
+--MAP_GEN = require "map_gen.presets.mobius_strip"
+--MAP_GEN = require "map_gen.presets.antfarm"
+--MAP_GEN = require "map_gen.presets.creation_of_adam"
+--MAP_GEN = require "map_gen.presets.manhattan"
+--MAP_GEN = require "map_gen.presets.mona_lisa"
+--MAP_GEN = require "map_gen.presets.connected_dots"
+--MAP_GEN = require "map_gen.presets.cage"
+--MAP_GEN = require "map_gen.presets.maori"
+--MAP_GEN = require "map_gen.presets.goat"
+--MAP_GEN = require "map_gen.presets.biome_test"
+--MAP_GEN = require "map_gen.presets.GoT"
+--MAP_GEN = require "map_gen.presets.turkey"
+--MAP_GEN = require "map_gen.presets.north_america"
 
 --shapes--
 --require "map_gen.shape.left"