1
0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-14 10:13:13 +02:00
RedMew/map_gen/maps/diggy/template.lua

194 lines
6.1 KiB
Lua
Raw Normal View History

-- dependencies
2019-01-04 22:02:55 +02:00
local Task = require 'utils.task'
2018-11-26 03:07:03 +02:00
local Token = require 'utils.token'
local Event = require 'utils.event'
local min = math.min
local ceil = math.ceil
local raise_event = script.raise_event
local queue_task = Task.queue_task
local pairs = pairs
local pcall = pcall
local string_find = string.find
-- this
local Template = {}
local tiles_per_call = 8 --how many tiles are inserted with each call of insert_action
local entities_per_call = 8 --how many entities are inserted with each call of insert_action
Template.events = {
--[[--
When an entity is placed via the template function.
- event.entity LuaEntity
]]
on_placed_entity = Event.generate_event_name('on_placed_entity'),
--[[--
Triggers when an 'out-of-map' tile is replaced by something else.
{surface, old_tile={name, position={x, y}}}
]]
on_void_removed = Event.generate_event_name('on_void_removed'),
}
local on_void_removed = Template.events.on_void_removed
local on_placed_entity = Template.events.on_placed_entity
local function insert_next_tiles(data)
local void_removed = {}
local void_removed_count = 0
local surface = data.surface
local get_tile = surface.get_tile
local tiles = {}
local tile_count = 0
local tile_iterator = data.tile_iterator
local teleported = {}
local teleported_count = 0
local teleport_offset = tiles_per_call + 5
local find_entities_filtered = surface.find_entities_filtered
pcall(function()
--use pcall to assure tile_iterator is always incremented, to avoid endless loops
local rocks_lookup = Template.diggy_rocks
for i = tile_iterator, min(tile_iterator + tiles_per_call - 1, data.tiles_n) do
local new_tile = data.tiles[i]
tile_count = tile_count + 1
tiles[tile_count] = new_tile
local tile_pos = new_tile.position
if new_tile.name ~= 'out-of-map' then
local current_tile = get_tile(tile_pos.x, tile_pos.y)
if current_tile.name == 'out-of-map' then
void_removed_count = void_removed_count + 1
void_removed[void_removed_count] = {surface = surface, position = current_tile.position}
end
end
if string_find(new_tile.name, "water", 1, true) then --maybe check prototype's collision mask instead?
local entities = find_entities_filtered{area = {tile_pos, {tile_pos.x + 1, tile_pos.y + 1}}, name = rocks_lookup}
2019-09-15 11:00:23 +02:00
for k = 1, #entities do
local entity = entities[k]
2019-09-15 10:47:18 +02:00
--entity.teleport(x, y) offsets the entity by specified values
if entity.teleport(teleport_offset) then
teleported_count = teleported_count + 1
teleported[teleported_count] = entity
else
2019-09-15 10:47:18 +02:00
log("WARNING: entity " .. entity.name .. " failed to teleport out of the way at " .. serpent.line(entity.position))
end
end
end
end
end)
data.tile_iterator = tile_iterator + tiles_per_call
surface.set_tiles(tiles)
for i = 1, teleported_count do
local entity = teleported[i]
2019-09-15 10:47:18 +02:00
entity.teleport(-teleport_offset)
end
for i = 1, void_removed_count do
raise_event(on_void_removed, void_removed[i])
end
end
local function insert_next_entities(data)
local created_entities = {}
local created_entities_count = 0
local surface = data.surface
local create_entity = surface.create_entity
pcall(function()
--use pcall to assure tile_iterator is always incremented, to avoid endless loops
for i = data.entity_iterator, min(data.entity_iterator + entities_per_call - 1, data.entities_n) do
created_entities_count = created_entities_count + 1
created_entities[created_entities_count] = create_entity(data.entities[i])
end
end)
data.entity_iterator = data.entity_iterator + entities_per_call
for i = 1, created_entities_count do
raise_event(on_placed_entity, {entity = created_entities[i]})
end
return data.entity_iterator <= data.entities_n
end
local function insert_action(data)
if data.tile_iterator <= data.tiles_n then
insert_next_tiles(data)
return true
end
return insert_next_entities(data)
end
local insert_token = Token.register(insert_action)
--[[--
Inserts a batch of tiles and then entities.
@see LuaSurface.set_tiles
@see LuaSurface.entity
@param surface LuaSurface to put the tiles and entities on
@param tiles table of tiles as required by set_tiles
@param entities table of entities as required by create_entity
]]
function Template.insert(surface, tiles, entities)
tiles = tiles or {}
entities = entities or {}
local tiles_n = #tiles
local entities_n = #entities
local total_calls = ceil(tiles_n / tiles_per_call) + (entities_n / entities_per_call)
local data = {
tiles_n = tiles_n,
tile_iterator = 1,
entities_n = entities_n,
entity_iterator = 1,
surface = surface,
tiles = tiles,
entities = entities
}
local continue = true
for _ = 1, 4 do
continue = insert_action(data)
if not continue then
return
end
end
if continue then
queue_task(insert_token, data, total_calls - 4)
end
end
--[[--
Designed to spawn resources.
@see LuaSurface.entity
@param surface LuaSurface to put the tiles and entities on
@param resources table of entities as required by create_entity
]]
function Template.resources(surface, resources)
local create_entity = surface.create_entity
for _, entity in pairs(resources) do
create_entity(entity)
end
end
Template.diggy_rocks = {'sand-rock-big', 'rock-big', 'rock-huge'}
2018-12-01 18:58:22 +02:00
---Returns true if the entity name is that of a diggy rock.
---@param entity_name string
function Template.is_diggy_rock(entity_name)
return entity_name == 'sand-rock-big' or entity_name == 'rock-big' or entity_name == 'rock-huge'
end
return Template