mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-26 03:52:22 +02:00
98c166ed82
Fused boss units into biter_health_booster. Unit evasion replaced with custom unit health pool. Boss Units no longer update their healthbar infinitely fast. Map Intro moved into the main panel. some globals to locals
355 lines
15 KiB
Lua
355 lines
15 KiB
Lua
local map_functions = require "tools.map_functions"
|
|
local simplex_noise = require "utils.simplex_noise".d2
|
|
local math_random = math.random
|
|
local math_abs = math.abs
|
|
local math_floor = math.floor
|
|
local math_sqrt = math.sqrt
|
|
|
|
local hourglass_center_piece_length = 64
|
|
local worm_raffle_table = {
|
|
[1] = {"small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret"},
|
|
[2] = {"small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret", "medium-worm-turret"},
|
|
[3] = {"small-worm-turret", "small-worm-turret", "small-worm-turret", "small-worm-turret", "medium-worm-turret", "medium-worm-turret"},
|
|
[4] = {"small-worm-turret", "small-worm-turret", "small-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret"},
|
|
[5] = {"small-worm-turret", "small-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "big-worm-turret"},
|
|
[6] = {"small-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "big-worm-turret"},
|
|
[7] = {"medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "big-worm-turret", "big-worm-turret"},
|
|
[8] = {"medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "big-worm-turret", "big-worm-turret"},
|
|
[9] = {"medium-worm-turret", "medium-worm-turret", "medium-worm-turret", "big-worm-turret", "big-worm-turret", "big-worm-turret"},
|
|
[10] = {"medium-worm-turret", "medium-worm-turret", "big-worm-turret", "big-worm-turret", "big-worm-turret", "big-worm-turret"}
|
|
}
|
|
local rock_raffle = {"sand-rock-big","sand-rock-big","rock-big","rock-big","rock-big","rock-big","rock-big","rock-big","rock-huge"}
|
|
|
|
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 return tile.name end
|
|
end
|
|
end
|
|
return "grass-1"
|
|
end
|
|
|
|
local function is_enemy_territory(p)
|
|
if p.x - 64 < math_abs(p.y) then return false end
|
|
--if p.x - 64 < p.y then return false end
|
|
if p.x < 160 then return false end
|
|
if p.x > 1024 then return false end
|
|
if p.y > 512 then return false end
|
|
if p.y < -512 then return false end
|
|
local noise = math_abs(simplex_noise(0, p.y * 0.015, game.surfaces[1].map_gen_settings.seed) * 96)
|
|
local noise_2 = math_abs(simplex_noise(0, p.y * 0.1, game.surfaces[1].map_gen_settings.seed) * 16)
|
|
if p.x > 288 + noise + noise_2 + math_abs(p.y * 0.75) then return false end
|
|
return true
|
|
end
|
|
|
|
local body_radius = 3072
|
|
local body_square_radius = body_radius ^ 2
|
|
local body_center_position = {x = -1500, y = 0}
|
|
local body_spacing = math_floor(body_radius * 0.82)
|
|
local body_circle_center_1 = {x = body_center_position.x, y = body_center_position.y - body_spacing}
|
|
local body_circle_center_2 = {x = body_center_position.x, y = body_center_position.y + body_spacing}
|
|
|
|
local fin_radius = 800
|
|
local square_fin_radius = fin_radius ^ 2
|
|
local fin_circle_center_1 = {x = -480, y = 0}
|
|
local fin_circle_center_2 = {x = -480 - 360, y = 0}
|
|
|
|
local function is_body(p)
|
|
if p.y <= map_height and p.y >= map_height * -1 and p.x <= 160 and p.x > body_center_position.x then return true end
|
|
|
|
--Main Fish Body
|
|
local distance_to_center_1 = ((p.x - body_circle_center_1.x)^2 + (p.y - body_circle_center_1.y)^2)
|
|
local distance_to_center_2 = ((p.x - body_circle_center_2.x)^2 + (p.y - body_circle_center_2.y)^2)
|
|
if distance_to_center_1 < body_square_radius and distance_to_center_2 < body_square_radius then return true end
|
|
|
|
--Fish Fins
|
|
local distance_to_center_1 = ((p.x - fin_circle_center_1.x)^2 + (p.y - fin_circle_center_1.y)^2)
|
|
if distance_to_center_1 + math_abs(simplex_noise(0, p.y * 0.075, game.surfaces[1].map_gen_settings.seed) * 32000) > square_fin_radius then
|
|
local distance_to_center_2 = ((p.x - fin_circle_center_2.x)^2 + (p.y - fin_circle_center_2.y)^2)
|
|
if distance_to_center_2 < square_fin_radius then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
local function is_out_of_map_tile(p)
|
|
if p.y > 850 then return true end
|
|
if p.y < -850 then return true end
|
|
if p.x < -3264 then return true end
|
|
if p.x > 800 then return true end
|
|
if is_enemy_territory(p) then return false end
|
|
if is_body(p) then return false end
|
|
return true
|
|
end
|
|
|
|
local function generate_spawn_area(surface)
|
|
surface.request_to_generate_chunks({x = 0, y = 0}, 7)
|
|
surface.request_to_generate_chunks({x = 160, y = 0}, 5)
|
|
--surface.force_generate_chunk_requests()
|
|
if global.spawn_area_generated then return end
|
|
if not surface.is_chunk_generated({-7, 0}) then return end
|
|
if not surface.is_chunk_generated({5, 0}) then return end
|
|
global.spawn_area_generated = true
|
|
|
|
local spawn_position_x = -128
|
|
|
|
surface.create_entity({name = "electric-beam", position = {160, -96}, source = {160, -96}, target = {160,96}})
|
|
|
|
for _, tile in pairs(surface.find_tiles_filtered({name = {"water", "deepwater"}, area = {{-160, -160},{160, 160}}})) do
|
|
local noise = math_abs(simplex_noise(tile.position.x * 0.02, tile.position.y * 0.02, game.surfaces[1].map_gen_settings.seed) * 16)
|
|
if tile.position.x > -160 + noise then surface.set_tiles({{name = get_replacement_tile(surface, tile.position), position = {tile.position.x, tile.position.y}}}, true) end
|
|
end
|
|
|
|
for _, entity in pairs(surface.find_entities_filtered({type = {"resource", "cliff"}, area = {{spawn_position_x - 32, -256},{160, 256}}})) do
|
|
if is_body(entity.position) then
|
|
if entity.position.x > spawn_position_x - 32 + math_abs(simplex_noise(entity.position.x * 0.02, entity.position.y * 0.02, game.surfaces[1].map_gen_settings.seed) * 16) then
|
|
entity.destroy()
|
|
end
|
|
end
|
|
end
|
|
|
|
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
|
|
for x = -4, 4, 1 do
|
|
for y = -3, 3, 1 do
|
|
surface.regenerate_decorative(decorative_names, {{x,y}})
|
|
end
|
|
end
|
|
|
|
local y = 80
|
|
local ore_positions = {{x = spawn_position_x - 52, y = y},{x = spawn_position_x - 52, y = y * 0.5},{x = spawn_position_x - 52, y = 0},{x = spawn_position_x - 52, y = y * -0.5},{x = spawn_position_x - 52, y = y * -1}}
|
|
table.shuffle_table(ore_positions)
|
|
map_functions.draw_smoothed_out_ore_circle(ore_positions[1], "copper-ore", surface, 15, 2500)
|
|
map_functions.draw_smoothed_out_ore_circle(ore_positions[2], "iron-ore", surface, 15, 2500)
|
|
map_functions.draw_smoothed_out_ore_circle(ore_positions[3], "coal", surface, 15, 1500)
|
|
map_functions.draw_smoothed_out_ore_circle(ore_positions[4], "stone", surface, 15, 1500)
|
|
map_functions.draw_noise_tile_circle({x = spawn_position_x - 20, y = 0}, "water", surface, 16)
|
|
map_functions.draw_oil_circle(ore_positions[5], "crude-oil", surface, 8, 200000)
|
|
|
|
local pos = surface.find_non_colliding_position("market",{spawn_position_x, 0}, 50, 1)
|
|
global.market = place_fish_market(surface, pos)
|
|
|
|
local r = 16
|
|
for _, entity in pairs(surface.find_entities_filtered({area = {{global.market.position.x - r, global.market.position.y - r}, {global.market.position.x + r, global.market.position.y + r}}, type = "tree"})) do
|
|
local distance_to_center = math_sqrt((entity.position.x - global.market.position.x)^2 + (entity.position.y - global.market.position.y)^2)
|
|
if distance_to_center < r then
|
|
if math_random(1, r) > distance_to_center then entity.destroy() end
|
|
end
|
|
end
|
|
|
|
local pos = surface.find_non_colliding_position("gun-turret",{spawn_position_x + 5, 1}, 50, 1)
|
|
local turret = surface.create_entity({name = "gun-turret", position = pos, force = "player"})
|
|
turret.insert({name = "firearm-magazine", count = 32})
|
|
|
|
for x = -20, 20, 1 do
|
|
for y = -20, 20, 1 do
|
|
local pos = {x = global.market.position.x + x, y = global.market.position.y + y}
|
|
local distance_to_center = math_sqrt(x^2 + y^2)
|
|
if distance_to_center > 8 and distance_to_center < 15 then
|
|
if math_random(1,3) == 1 and surface.can_place_entity({name = "wooden-chest", position = pos, force = "player"}) then
|
|
local chest = surface.create_entity({name = "wooden-chest", position = pos, force = "player"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local area = {{x = -160, y = -96}, {x = 160, y = 96}}
|
|
for _, tile in pairs(surface.find_tiles_filtered({name = "water", area = area})) do
|
|
if math_random(1, 32) == 1 then
|
|
surface.create_entity({name = "fish", position = tile.position})
|
|
end
|
|
end
|
|
|
|
local pos = surface.find_non_colliding_position("character",{spawn_position_x + 1, 4}, 50, 1)
|
|
game.forces["player"].set_spawn_position(pos, surface)
|
|
for _, player in pairs(game.connected_players) do
|
|
local pos = surface.find_non_colliding_position("character",{spawn_position_x + 1, 4}, 50, 1)
|
|
player.teleport(pos, surface)
|
|
end
|
|
end
|
|
|
|
local function enemy_territory(surface, left_top)
|
|
--surface.request_to_generate_chunks({x = 256, y = 0}, 16)
|
|
--surface.force_generate_chunk_requests()
|
|
|
|
if left_top.x < 160 then return end
|
|
if left_top.x > 750 then return end
|
|
if left_top.y > 512 then return end
|
|
if left_top.y < -512 then return end
|
|
|
|
local area = {{left_top.x, left_top.y},{left_top.x + 32, left_top.y + 32}}
|
|
|
|
--local area = {{160, -512},{750, 512}}
|
|
--for _, tile in pairs(surface.find_tiles_filtered({area = area})) do
|
|
-- if is_enemy_territory(tile.position) then
|
|
-- surface.set_tiles({{name = "water-mud", position = {tile.position.x, tile.position.y}}}, true)
|
|
-- end
|
|
--end
|
|
if left_top.x > 256 then
|
|
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 is_enemy_territory(pos) then
|
|
if math_random(1, 512) == 1 then
|
|
if surface.can_place_entity({name = "biter-spawner", force = "decoratives", position = pos}) then
|
|
local entity
|
|
if math_random(1,4) == 1 then
|
|
entity = surface.create_entity({name = "spitter-spawner", force = "decoratives", position = pos})
|
|
else
|
|
entity = surface.create_entity({name = "biter-spawner", force = "decoratives", position = pos})
|
|
end
|
|
entity.active = false
|
|
entity.destructible = false
|
|
end
|
|
end
|
|
--if pos.x % 32 == 0 and pos.y % 32 == 0 then
|
|
-- 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, {{x=math_floor(pos.x/32),y=math_floor(pos.y/32)}})
|
|
--end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for _, entity in pairs(surface.find_entities_filtered({area = area, type = {"tree", "cliff"}})) do
|
|
if is_enemy_territory(entity.position) then entity.destroy() end
|
|
end
|
|
for _, entity in pairs(surface.find_entities_filtered({area = area, type = "resource"})) do
|
|
if is_enemy_territory(entity.position) then
|
|
surface.create_entity({name = "uranium-ore", position = entity.position, amount = math_random(200, 8000)})
|
|
entity.destroy()
|
|
end
|
|
end
|
|
for _, tile in pairs(surface.find_tiles_filtered({name = {"water", "deepwater"}, area = area})) do
|
|
if is_enemy_territory(tile.position) then
|
|
surface.set_tiles({{name = get_replacement_tile(surface, tile.position), position = {tile.position.x, tile.position.y}}}, true)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function fish_mouth(surface, left_top)
|
|
if left_top.x > -2300 then return end
|
|
if left_top.y > 64 then return end
|
|
if left_top.y < -64 then return end
|
|
if left_top.x < -3292 then return end
|
|
|
|
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 noise = simplex_noise(pos.x * 0.006, 0, game.surfaces[1].map_gen_settings.seed) * 20
|
|
if pos.y <= 12 + noise and pos.y >= -12 + noise then surface.set_tiles({{name = "water", position = pos}}) end
|
|
end
|
|
end
|
|
end
|
|
|
|
function fish_eye(surface, position)
|
|
surface.request_to_generate_chunks(position, 2)
|
|
surface.force_generate_chunk_requests()
|
|
for x = -48, 48, 1 do
|
|
for y = -48, 48, 1 do
|
|
local p = {x = position.x + x, y = position.y + y}
|
|
local distance = math_sqrt(((position.x - p.x) ^ 2) + ((position.y - p.y) ^ 2))
|
|
if distance < 44 then
|
|
surface.set_tiles({{name = "water-green", position = p}}, true)
|
|
end
|
|
if distance < 22 then
|
|
surface.set_tiles({{name = "out-of-map", position = p}}, true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local ores = {"coal", "iron-ore", "copper-ore", "stone"}
|
|
|
|
local function plankton_territory(surface, position, seed)
|
|
local noise = simplex_noise(position.x * 0.009, position.y * 0.009, seed)
|
|
local d = 196
|
|
if position.x + position.y > (d * -1) - (math_abs(noise) * d * 3) and position.x > position.y - (d + (math_abs(noise) * d * 3)) then return false end
|
|
|
|
local noise_2 = simplex_noise(position.x * 0.0075, position.y * 0.0075, seed + 10000)
|
|
if noise_2 > 0.87 then surface.set_tiles({{name = "deepwater-green", position = position}}, true) return true end
|
|
if noise_2 > 0.75 then
|
|
local i = math_floor(noise * 6) % 4 + 1
|
|
surface.set_tiles({{name = "grass-" .. i, position = position}}, true)
|
|
surface.create_entity({name = ores[i], position = position, amount = 1 + 2500 * math_abs(noise_2 * 3)})
|
|
return true
|
|
end
|
|
if noise_2 < -0.76 then
|
|
local i = math_floor(noise * 6) % 4 + 1
|
|
surface.set_tiles({{name = "grass-" .. i, position = position}}, true)
|
|
if noise_2 < -0.86 then surface.create_entity({name = "uranium-ore", position = position, amount = 1 + 1000 * math_abs(noise_2 * 2)}) return true end
|
|
if math_random(1, 3) ~= 1 then surface.create_entity({name = rock_raffle[math_random(1, #rock_raffle)], position = position}) end
|
|
return true
|
|
end
|
|
|
|
if noise < 0.12 and noise > -0.12 then
|
|
local i = math_floor(noise * 32) % 4 + 1
|
|
surface.set_tiles({{name = "grass-" .. i, position = position}}, true)
|
|
if math_random(1, 5) == 1 then surface.create_entity({name = rock_raffle[math_random(1, #rock_raffle)], position = position}) end
|
|
return true
|
|
end
|
|
|
|
surface.set_tiles({{name = "water", position = position}}, true)
|
|
if math_random(1, 128) == 1 then surface.create_entity({name = "fish", position = position}) end
|
|
|
|
return true
|
|
end
|
|
|
|
local function process_chunk(left_top)
|
|
local surface = game.surfaces["fish_defender"]
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
|
|
generate_spawn_area(surface)
|
|
enemy_territory(surface, left_top)
|
|
fish_mouth(surface, left_top)
|
|
|
|
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 is_out_of_map_tile(pos) then
|
|
if not plankton_territory(surface, pos, seed) then surface.set_tiles({{name = "out-of-map", position = pos}}, true) end
|
|
end
|
|
end
|
|
end
|
|
|
|
--if game.tick == 0 then return end
|
|
--if game.forces.player.is_chunk_charted(surface, {left_top.x / 32, left_top.y / 32}) then
|
|
game.forces.player.chart(surface, {{left_top.x, left_top.y},{left_top.x + 31, left_top.y + 31}})
|
|
--end
|
|
end
|
|
|
|
local function process_chunk_queue()
|
|
for k, left_top in pairs(global.chunk_queue) do
|
|
process_chunk(left_top)
|
|
global.chunk_queue[k] = nil
|
|
return
|
|
end
|
|
end
|
|
|
|
local function on_chunk_generated(event)
|
|
if game.surfaces["fish_defender"].index ~= event.surface.index then return end
|
|
local left_top = event.area.left_top
|
|
|
|
if game.tick == 0 then
|
|
process_chunk(left_top)
|
|
else
|
|
table.insert(global.chunk_queue, {x = left_top.x, y = left_top.y})
|
|
end
|
|
end
|
|
|
|
local event = require 'utils.event'
|
|
event.on_nth_tick(25, process_chunk_queue)
|
|
event.add(defines.events.on_chunk_generated, on_chunk_generated) |