mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-10 00:43:27 +02:00
579 lines
20 KiB
Lua
579 lines
20 KiB
Lua
local bb_config = require "maps.biter_battles_v2.config"
|
|
local event = require 'utils.event'
|
|
local Server = require 'utils.server'
|
|
local math_random = math.random
|
|
local math_abs = math.abs
|
|
local simplex_noise = require 'utils.simplex_noise'.d2
|
|
local create_tile_chain = require "functions.create_tile_chain"
|
|
local spawn_circle_size = 32
|
|
local ores = {"copper-ore", "iron-ore", "stone", "coal"}
|
|
local rocks = {"sand-rock-big","sand-rock-big","rock-big","rock-big","rock-big","rock-big", "rock-huge"}
|
|
|
|
local function shuffle(tbl)
|
|
local size = #tbl
|
|
for i = size, 1, -1 do
|
|
local rand = math_random(size)
|
|
tbl[i], tbl[rand] = tbl[rand], tbl[i]
|
|
end
|
|
return tbl
|
|
end
|
|
|
|
local function get_noise(name, pos)
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local noise_seed_add = 25000
|
|
if name == 1 then
|
|
local noise = {}
|
|
noise[1] = simplex_noise(pos.x * 0.0042, pos.y * 0.0042, seed)
|
|
seed = seed + noise_seed_add
|
|
noise[2] = simplex_noise(pos.x * 0.031, pos.y * 0.031, seed)
|
|
seed = seed + noise_seed_add
|
|
noise[3] = simplex_noise(pos.x * 0.1, pos.y * 0.1, seed)
|
|
local noise = noise[1] + noise[2] * 0.08 + noise[3] * 0.025
|
|
return noise
|
|
end
|
|
if name == 2 then
|
|
local noise = {}
|
|
noise[1] = simplex_noise(pos.x * 0.011, pos.y * 0.011, seed)
|
|
seed = seed + noise_seed_add
|
|
noise[2] = simplex_noise(pos.x * 0.08, pos.y * 0.08, seed)
|
|
local noise = noise[1] + noise[2] * 0.2
|
|
return noise
|
|
end
|
|
if name == 3 then
|
|
local noise = {}
|
|
noise[1] = simplex_noise(pos.x * 0.02, pos.y * 0.02, seed)
|
|
seed = seed + noise_seed_add
|
|
noise[2] = simplex_noise(pos.x * 0.08, pos.y * 0.08, seed)
|
|
local noise = noise[1] + noise[2] * 0.1
|
|
return noise
|
|
end
|
|
end
|
|
|
|
local function get_replacement_tile(surface, position)
|
|
for i = 1, 128, 1 do
|
|
local vectors = {{0, i}, {0, i * -1}, {i, 0}, {i * -1, 0}}
|
|
table.shuffle_table(vectors)
|
|
for k, v in pairs(vectors) do
|
|
local tile = surface.get_tile(position.x + v[1], position.y + v[2])
|
|
if not tile.collides_with("resource-layer") then
|
|
if tile.name ~= "stone-path" then
|
|
return tile.name
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return "grass-1"
|
|
end
|
|
|
|
local function get_chunk_position(position)
|
|
local chunk_position = {}
|
|
position.x = math.floor(position.x, 0)
|
|
position.y = math.floor(position.y, 0)
|
|
for x = 0, 31, 1 do
|
|
if (position.x - x) % 32 == 0 then chunk_position.x = (position.x - x) / 32 end
|
|
end
|
|
for y = 0, 31, 1 do
|
|
if (position.y - y) % 32 == 0 then chunk_position.y = (position.y - y) / 32 end
|
|
end
|
|
return chunk_position
|
|
end
|
|
|
|
local function regenerate_decoratives(surface, position)
|
|
local chunk = get_chunk_position(position)
|
|
if not chunk then return end
|
|
surface.destroy_decoratives({area = {{chunk.x * 32, chunk.y * 32}, {chunk.x * 32 + 32, chunk.y * 32 + 32}}})
|
|
local decorative_names = {}
|
|
for k,v in pairs(game.decorative_prototypes) do
|
|
if v.autoplace_specification then
|
|
decorative_names[#decorative_names+1] = k
|
|
end
|
|
end
|
|
surface.regenerate_decorative(decorative_names, {chunk})
|
|
end
|
|
|
|
local function draw_noise_ore_patch(position, name, surface, radius, richness)
|
|
if not position then return end
|
|
if not name then return end
|
|
if not surface then return end
|
|
if not radius then return end
|
|
if not richness then return end
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local noise_seed_add = 25000
|
|
local richness_part = richness / radius
|
|
for y = radius * -3, radius * 3, 1 do
|
|
for x = radius * -3, radius * 3, 1 do
|
|
local pos = {x = x + position.x + 0.5, y = y + position.y + 0.5}
|
|
local noise_1 = simplex_noise(pos.x * 0.0125, pos.y * 0.0125, seed)
|
|
local noise_2 = simplex_noise(pos.x * 0.1, pos.y * 0.1, seed + 25000)
|
|
local noise = noise_1 + noise_2 * 0.12
|
|
local distance_to_center = math.sqrt(x^2 + y^2)
|
|
local a = richness - richness_part * distance_to_center
|
|
if distance_to_center < radius - math.abs(noise * radius * 0.85) and a > 1 then
|
|
if surface.can_place_entity({name = name, position = pos, amount = a}) then
|
|
surface.create_entity{name = name, position = pos, amount = a}
|
|
|
|
local mirror_pos = {x = pos.x * -1, y = pos.y * -1}
|
|
surface.create_entity{name = name, position = mirror_pos, amount = a}
|
|
|
|
for _, e in pairs(surface.find_entities_filtered({position = pos, name = {"wooden-chest", "stone-wall", "gun-turret"}})) do
|
|
e.destroy()
|
|
end
|
|
for _, e in pairs(surface.find_entities_filtered({position = mirror_pos, name = {"wooden-chest", "stone-wall", "gun-turret"}})) do
|
|
e.destroy()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function is_within_spawn_circle(pos)
|
|
if math.abs(pos.x) > spawn_circle_size then return false end
|
|
if math.abs(pos.y) > spawn_circle_size then return false end
|
|
if math.sqrt(pos.x ^ 2 + pos.y ^ 2) > spawn_circle_size then return false end
|
|
return true
|
|
end
|
|
|
|
local river_y_1 = bb_config.border_river_width * -1.5
|
|
local river_y_2 = bb_config.border_river_width * 1.5
|
|
function is_horizontal_border_river(pos)
|
|
if pos.y < river_y_1 then return false end
|
|
if pos.y > river_y_2 then return false end
|
|
if pos.y > -5 and pos.x > -5 and pos.x < 5 then return false end
|
|
if math.floor(bb_config.border_river_width * -0.5) < pos.y + (get_noise(1, pos) * 5) then return true end
|
|
return false
|
|
end
|
|
|
|
local function generate_circle_spawn(event)
|
|
if global.bb_spawn_generated then return end
|
|
|
|
local surface = event.surface
|
|
|
|
local left_top_x = event.area.left_top.x
|
|
local left_top_y = event.area.left_top.y
|
|
|
|
if left_top_x < -320 then return end
|
|
if left_top_x > 320 then return end
|
|
if left_top_y < -320 then return end
|
|
|
|
local r = 116
|
|
for x = 0, 31, 1 do
|
|
for y = 0, 31, 1 do
|
|
local pos = {x = left_top_x + x, y = left_top_y + y}
|
|
local distance_to_center = math.sqrt(pos.x ^ 2 + pos.y ^ 2)
|
|
local noise = get_noise(2, pos) * 15
|
|
|
|
local tile = false
|
|
if distance_to_center < spawn_circle_size then
|
|
tile = "deepwater"
|
|
if math_random(1, 48) == 1 then surface.create_entity({name = "fish", position = pos}) end
|
|
end
|
|
if distance_to_center < 9.5 then tile = "refined-concrete" end
|
|
if distance_to_center < 7 then tile = "sand-1" end
|
|
|
|
if distance_to_center + noise < r - 10 and distance_to_center > spawn_circle_size and not is_horizontal_border_river(pos) then
|
|
local tile_name = surface.get_tile(pos).name
|
|
if tile_name == "water" or tile_name == "deepwater" then
|
|
surface.set_tiles({{name = get_replacement_tile(surface, pos), position = pos}}, true)
|
|
end
|
|
end
|
|
|
|
if tile then surface.set_tiles({{name = tile, position = pos}}, true) end
|
|
|
|
if surface.can_place_entity({name = "wooden-chest", position = pos}) and surface.can_place_entity({name = "coal", position = pos}) then
|
|
local noise_2 = get_noise(3, pos)
|
|
if noise_2 < 0.25 then
|
|
local spawn_wall_r = distance_to_center + noise
|
|
if noise_2 > -0.5 then
|
|
if spawn_wall_r < r and spawn_wall_r > r - 1.75 then
|
|
surface.create_entity({name = "stone-wall", position = pos, force = "north"})
|
|
end
|
|
else
|
|
if spawn_wall_r < r and spawn_wall_r > r - 1.95 then
|
|
surface.create_entity({name = "stone-wall", position = pos, force = "north"})
|
|
else
|
|
if spawn_wall_r < r + 4.5 and spawn_wall_r > r then
|
|
local name = "wooden-chest"
|
|
local r_max = math.floor(math.abs(spawn_wall_r - r)) + 2
|
|
if math_random(1,3) == 1 then name = name .. "-remnants" end
|
|
if math_random(1,r_max) == 1 then surface.create_entity({name = name, position = pos, force = "north"}) end
|
|
end
|
|
end
|
|
if spawn_wall_r < r - 3 and spawn_wall_r > r - 6 then
|
|
if math_random(1, 16) == 1 then
|
|
if surface.can_place_entity({name = "gun-turret", position = pos}) then
|
|
local t = surface.create_entity({name = "gun-turret", position = pos, force = "north"})
|
|
t.insert({name = "firearm-magazine", count = math_random(6,12)})
|
|
end
|
|
else
|
|
if math_random(1, 16) == 1 then
|
|
if surface.can_place_entity({name = "gun-turret", position = pos}) then
|
|
surface.create_entity({name = "gun-turret-remnants", position = pos, force = "north"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
regenerate_decoratives(surface, event.area.left_top)
|
|
end
|
|
|
|
local function generate_north_silo(surface)
|
|
local pos = {x = -12 + math.random(0, 24), y = -64 + math.random(0, 16)}
|
|
|
|
for _, t in pairs(surface.find_tiles_filtered({area = {{pos.x - 6, pos.y - 6},{pos.x + 6, pos.y + 6}}, name = {"water", "deepwater"}})) do
|
|
surface.set_tiles({{name = get_replacement_tile(surface, t.position), position = t.position}})
|
|
end
|
|
|
|
global.rocket_silo["north"] = surface.create_entity({
|
|
name = "rocket-silo",
|
|
position = pos,
|
|
force = "north"
|
|
})
|
|
global.rocket_silo["north"].minable = false
|
|
|
|
for i = 1, 32, 1 do
|
|
create_tile_chain(surface, {name = "stone-path", position = global.rocket_silo["north"].position}, 32, 10)
|
|
end
|
|
end
|
|
|
|
local function generate_river(event)
|
|
if event.area.left_top.y < -32 then return end
|
|
local surface = event.surface
|
|
local left_top_x = event.area.left_top.x
|
|
local left_top_y = event.area.left_top.y
|
|
for x = 0, 31, 1 do
|
|
for y = 0, 31, 1 do
|
|
local pos = {x = left_top_x + x, y = left_top_y + y}
|
|
local distance_to_center = math.sqrt(pos.x ^ 2 + pos.y ^ 2)
|
|
if is_horizontal_border_river(pos) then
|
|
surface.set_tiles({{name = "deepwater", position = pos}})
|
|
if math_random(1, 64) == 1 then surface.create_entity({name = "fish", position = pos}) end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function generate_potential_spawn_ore(surface)
|
|
local r = 130
|
|
local area = {{r * -1, r * -1}, {r, 0}}
|
|
local ores = {}
|
|
ores["iron-ore"] = surface.count_entities_filtered({name = "iron-ore", area = area})
|
|
ores["copper-ore"] = surface.count_entities_filtered({name = "copper-ore", area = area})
|
|
ores["coal"] = surface.count_entities_filtered({name = "coal", area = area})
|
|
ores["stone"] = surface.count_entities_filtered({name = "stone", area = area})
|
|
for ore, ore_count in pairs(ores) do
|
|
if ore_count < 250 or ore_count == nil then
|
|
local pos = {}
|
|
for a = 1, 32, 1 do
|
|
pos = {x = -96 + math_random(0, 192), y = -20 - math_random(0, 96)}
|
|
if surface.can_place_entity({name = "coal", position = pos, amount = 1}) then
|
|
break
|
|
end
|
|
end
|
|
draw_noise_ore_patch(pos, ore, surface, math_random(16, 24), math_random(800, 1600))
|
|
end
|
|
end
|
|
end
|
|
|
|
local worm_turrets = {
|
|
[1] = "small-worm-turret",
|
|
[2] = "medium-worm-turret",
|
|
[3] = "big-worm-turret",
|
|
[4] = "behemoth-worm-turret"
|
|
}
|
|
|
|
local worm_tile_coords = {}
|
|
for x = 0, 31, 1 do
|
|
for y = 0, 31, 1 do
|
|
worm_tile_coords[#worm_tile_coords + 1] = {x, y}
|
|
end
|
|
end
|
|
|
|
local worm_chance = 15
|
|
local function generate_extra_worm_turrets(surface, left_top)
|
|
local chunk_distance_to_center = math.sqrt(left_top.x ^ 2 + left_top.y ^ 2)
|
|
if bb_config.bitera_area_distance > chunk_distance_to_center then return end
|
|
|
|
for a = 1, 256, 1 do
|
|
if math_random(1, 100) > worm_chance then break end
|
|
local coord_modifier = worm_tile_coords[math_random(1, #worm_tile_coords)]
|
|
local pos = {left_top.x + coord_modifier[1], left_top.y + coord_modifier[2]}
|
|
local position = surface.find_non_colliding_position("big-worm-turret", pos, 8, 1)
|
|
if position then
|
|
local highest_worm_tier = math.floor((chunk_distance_to_center - bb_config.bitera_area_distance) * 0.002) + 1
|
|
if highest_worm_tier > 4 then highest_worm_tier = 4 end
|
|
local name = worm_turrets[math_random(1, highest_worm_tier)]
|
|
surface.create_entity({name = name, position = position, force = "north_biters"})
|
|
end
|
|
end
|
|
end
|
|
|
|
local scrap_vectors = {}
|
|
for x = -5, 5, 1 do
|
|
for y = -5, 5, 1 do
|
|
if math.sqrt(x^2 + y^2) <= 5 then
|
|
scrap_vectors[#scrap_vectors + 1] = {x, y}
|
|
end
|
|
end
|
|
end
|
|
|
|
local function generate_scrap(event)
|
|
local distance_to_center = math.sqrt(event.area.left_top.x ^ 2 + event.area.left_top.y ^ 2)
|
|
|
|
local worms = event.surface.find_entities_filtered({area = event.area, type = "turret"})
|
|
if #worms == 0 then return end
|
|
|
|
for _, e in pairs(worms) do
|
|
if math_random(1,2) == 1 then
|
|
for c = 1, math_random(2,12), 1 do
|
|
local vector = scrap_vectors[math_random(1, #scrap_vectors)]
|
|
local position = {e.position.x + vector[1], e.position.y + vector[2]}
|
|
if e.surface.can_place_entity({name = "mineable-wreckage", position = position, force = "neutral"}) then
|
|
e.surface.create_entity({name = "mineable-wreckage", position = position, force = "neutral"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function is_biter_area(position)
|
|
--if position.x + position.y > -352 + (get_noise(3, position) * 16) then return false end
|
|
if position.y + (get_noise(3, position) * 16) > (bb_config.bitera_area_distance * -1) - (math.abs(position.x) * 0.33) then return false end
|
|
return true
|
|
end
|
|
|
|
local function builders_area_process_entity(e)
|
|
if is_biter_area(e.position) then
|
|
if e.type == "resource" then
|
|
e.destroy()
|
|
return
|
|
end
|
|
if e.type == "turret" then
|
|
e.destroy()
|
|
return
|
|
end
|
|
if e.type == "cliff" then
|
|
e.destroy()
|
|
return
|
|
end
|
|
if e.type == "tree" then
|
|
if math_random(1, 32) == 1 then e.surface.create_entity({name = "rock-big", position = e.position, force = "neutral"}) end
|
|
e.destroy()
|
|
return
|
|
end
|
|
else
|
|
if e.type == "turret" or e.type == "unit-spawner" then
|
|
e.destroy()
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
local function builders_area_process_tile(t, surface)
|
|
if is_horizontal_border_river(t.position) then return end
|
|
if not is_biter_area(t.position) then return end
|
|
local noise_index = math.floor(math.abs(get_noise(3, t.position)) * 7) + 1
|
|
if noise_index > 7 then noise_index = 7 end
|
|
surface.set_tiles({{name = "dirt-" .. noise_index, position = t.position}})
|
|
|
|
if math_random(1, 160) == 1 then
|
|
if t.position.x ^ 2 + t.position.y ^ 2 < 129600 then return end
|
|
local spawner_position = surface.find_non_colliding_position("biter-spawner", t.position, 8, 1)
|
|
if spawner_position then
|
|
if math_random(1, 4) == 1 then
|
|
surface.create_entity({name = "spitter-spawner", position = spawner_position, force = "north_biters"})
|
|
else
|
|
surface.create_entity({name = "biter-spawner", position = spawner_position, force = "north_biters"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function mixed_ore(event)
|
|
local surface = event.surface
|
|
local left_top_x = event.area.left_top.x
|
|
local left_top_y = event.area.left_top.y
|
|
|
|
--Draw noise text values to determine which chunks are valid for mixed ore.
|
|
--rendering.draw_text{text = get_noise(1, {x = left_top_x + 16, y = left_top_y + 16}), surface = surface, target = {x = left_top_x + 16, y = left_top_y + 16}, color = {255, 255, 255}, time_to_live = 3600, scale = 2, font = "default-game"}
|
|
|
|
--Skip chunks that are too far off the ore noise value.
|
|
if get_noise(1, {x = left_top_x + 16, y = left_top_y + 16}) < 0.52 then return end
|
|
|
|
--Draw the mixed ore patches.
|
|
for x = 0, 31, 1 do
|
|
for y = 0, 31, 1 do
|
|
local pos = {x = left_top_x + x, y = left_top_y + y}
|
|
if surface.can_place_entity({name = "iron-ore", position = pos}) then
|
|
local noise = get_noise(1, pos)
|
|
if noise > 0.81 then
|
|
local amount = math_random(1250, 1500) + math.sqrt(pos.x ^ 2 + pos.y ^ 2) * 1.1
|
|
local m = (noise - 0.75) * 16
|
|
amount = amount * m
|
|
local i = math.ceil(math.abs(noise * 35)) % 4
|
|
if i == 0 then i = 4 end
|
|
surface.create_entity({name = ores[i], position = pos, amount = amount})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
--[[
|
|
local cliff_vectors = {}
|
|
local cliff_brush_radius = 3.5
|
|
for x = cliff_brush_radius * -1, cliff_brush_radius, 0.5 do
|
|
for y = cliff_brush_radius * -1, cliff_brush_radius, 0.5 do
|
|
if math.sqrt(x^2 + y^2) < cliff_brush_radius then
|
|
cliff_vectors[#cliff_vectors + 1] = {x,y}
|
|
end
|
|
end
|
|
end
|
|
|
|
local function replace_cliff(surface, entity)
|
|
if surface.get_tile(entity.position).collides_with("resource-layer") then return end
|
|
for _, vector in pairs(cliff_vectors) do
|
|
if math_random(0, (math_abs(vector[1]) + math_abs(vector[2])) * 0.75) == 0 then
|
|
local position = {entity.position.x + vector[1], entity.position.y + vector[2]}
|
|
if surface.count_entities_filtered({type = "simple-entity", position = position}) == 0 then
|
|
surface.create_entity({name = rocks[math_random(1, 7)], position = position})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function replace_cliffs_with_rocks(surface, area)
|
|
for _, cliff in pairs(surface.find_entities_filtered({area = area, type = "cliff"})) do
|
|
replace_cliff(surface, cliff)
|
|
cliff.destroy()
|
|
end
|
|
end
|
|
]]
|
|
local function on_chunk_generated(event)
|
|
if event.area.left_top.y >= 0 then return end
|
|
local surface = event.surface
|
|
local left_top = event.area.left_top
|
|
if surface.name ~= "biter_battles" then return end
|
|
|
|
for _, e in pairs(surface.find_entities_filtered({area = event.area, force = "enemy"})) do
|
|
surface.create_entity({name = e.name, position = e.position, force = "north_biters", direction = e.direction})
|
|
e.destroy()
|
|
end
|
|
|
|
--replace_cliffs_with_rocks(surface, event.area)
|
|
|
|
mixed_ore(event)
|
|
generate_river(event)
|
|
generate_circle_spawn(event)
|
|
|
|
if bb_config.builders_area then
|
|
for _, t in pairs(surface.find_tiles_filtered({area = event.area, name = {"water", "deepwater"}})) do
|
|
builders_area_process_tile(t, surface)
|
|
end
|
|
for _, e in pairs(surface.find_entities_filtered({area = event.area})) do
|
|
builders_area_process_entity(e)
|
|
end
|
|
end
|
|
|
|
generate_extra_worm_turrets(surface, left_top)
|
|
|
|
if bb_config.random_scrap then
|
|
generate_scrap(event)
|
|
end
|
|
|
|
if global.bb_spawn_generated then return end
|
|
if game.tick > 0 then
|
|
generate_potential_spawn_ore(surface)
|
|
|
|
local area = {{-10,-10},{10,10}}
|
|
for _, e in pairs(surface.find_entities_filtered({area = area})) do
|
|
if e.name ~= "character" then e.destroy() end
|
|
end
|
|
surface.destroy_decoratives({area = area})
|
|
|
|
for _, silo in pairs(global.rocket_silo) do
|
|
for _, entity in pairs(surface.find_entities({{silo.position.x - 4, silo.position.y - 4}, {silo.position.x + 4, silo.position.y + 4}})) do
|
|
if entity.type == "simple-entity" or entity.type == "tree" or entity.type == "resource" then
|
|
entity.destroy()
|
|
end
|
|
end
|
|
end
|
|
|
|
global.bb_spawn_generated = true
|
|
end
|
|
end
|
|
|
|
--Landfill Restriction
|
|
local function restrict_landfill(surface, inventory, tiles)
|
|
for _, t in pairs(tiles) do
|
|
local distance_to_center = math.sqrt(t.position.x ^ 2 + t.position.y ^ 2)
|
|
local check_position = t.position
|
|
if check_position.y > 0 then check_position = {x = check_position.x * -1, y = (check_position.y * -1) - 1} end
|
|
if is_horizontal_border_river(check_position) or distance_to_center < spawn_circle_size then
|
|
surface.set_tiles({{name = t.old_tile.name, position = t.position}}, true)
|
|
inventory.insert({name = "landfill", count = 1})
|
|
end
|
|
end
|
|
end
|
|
local function on_player_built_tile(event)
|
|
local player = game.players[event.player_index]
|
|
restrict_landfill(player.surface, player, event.tiles)
|
|
end
|
|
local function on_robot_built_tile(event)
|
|
restrict_landfill(event.robot.surface, event.robot.get_inventory(defines.inventory.robot_cargo), event.tiles)
|
|
end
|
|
|
|
--Construction Robot Restriction
|
|
local robot_build_restriction = {
|
|
["north"] = function(y)
|
|
if y >= -10 then return true end
|
|
end,
|
|
["south"] = function(y)
|
|
if y <= 10 then return true end
|
|
end
|
|
}
|
|
|
|
local function on_robot_built_entity(event)
|
|
if not robot_build_restriction[event.robot.force.name] then return end
|
|
if not robot_build_restriction[event.robot.force.name](event.created_entity.position.y) then return end
|
|
local inventory = event.robot.get_inventory(defines.inventory.robot_cargo)
|
|
inventory.insert({name = event.created_entity.name, count = 1})
|
|
event.robot.surface.create_entity({name = "explosion", position = event.created_entity.position})
|
|
game.print("Team " .. event.robot.force.name .. "'s construction drone had an accident.", {r = 200, g = 50, b = 100})
|
|
event.created_entity.destroy()
|
|
end
|
|
|
|
local function on_marked_for_deconstruction(event)
|
|
if not event.entity.valid then return end
|
|
if event.entity.name == "fish" then event.entity.cancel_deconstruction(game.players[event.player_index].force.name) end
|
|
end
|
|
|
|
local function on_init(surface)
|
|
local surface = game.surfaces["biter_battles"]
|
|
if bb_config.on_init_pregen then
|
|
Server.to_discord_embed("Generating chunks...")
|
|
print("Generating chunks...")
|
|
surface.request_to_generate_chunks({x = 0, y = -512}, 16)
|
|
surface.request_to_generate_chunks({x = 1024, y = -512}, 16)
|
|
surface.request_to_generate_chunks({x = -1024, y = -512}, 16)
|
|
surface.force_generate_chunk_requests()
|
|
else
|
|
surface.request_to_generate_chunks({x = 0, y = -256}, 8)
|
|
surface.force_generate_chunk_requests()
|
|
end
|
|
generate_north_silo(surface)
|
|
end
|
|
|
|
event.on_init(on_init)
|
|
|
|
event.add(defines.events.on_marked_for_deconstruction, on_marked_for_deconstruction)
|
|
event.add(defines.events.on_entity_damaged, on_entity_damaged)
|
|
event.add(defines.events.on_robot_built_entity, on_robot_built_entity)
|
|
event.add(defines.events.on_robot_built_tile, on_robot_built_tile)
|
|
event.add(defines.events.on_player_built_tile, on_player_built_tile)
|
|
event.add(defines.events.on_chunk_generated, on_chunk_generated)
|