mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2024-12-30 23:17:53 +02:00
371 lines
12 KiB
Lua
371 lines
12 KiB
Lua
--luacheck: ignore
|
|
require 'modules.satellite_score'
|
|
require 'modules.thirst'
|
|
|
|
local Map_info = require 'modules.map_info'
|
|
|
|
local get_noise = require 'utils.math.get_noise'
|
|
local table_insert = table.insert
|
|
local math_random = math.random
|
|
local math_floor = math.floor
|
|
local math_abs = math.abs
|
|
local string_sub = string.sub
|
|
|
|
local oasis_start = 0.50
|
|
local water_start = 0.81
|
|
local sand_damage = oasis_start * 100 + 16
|
|
|
|
local trees = { 'tree-01', 'tree-04', 'tree-06', 'tree-08-red', 'tree-08', 'tree-09' }
|
|
|
|
local tile_to_item = {
|
|
['stone-path'] = 'stone-brick',
|
|
['hazard-concrete-left'] = 'hazard-concrete',
|
|
['hazard-concrete-right'] = 'hazard-concrete',
|
|
['refined-hazard-concrete-left'] = 'refined-hazard-concrete',
|
|
['refined-hazard-concrete-right'] = 'refined-hazard-concrete'
|
|
}
|
|
|
|
local save_tiles = {
|
|
['stone-path'] = true,
|
|
['concrete'] = true,
|
|
['hazard-concrete-left'] = true,
|
|
['hazard-concrete-right'] = true,
|
|
['refined-concrete'] = true,
|
|
['refined-hazard-concrete-left'] = true,
|
|
['refined-hazard-concrete-right'] = true,
|
|
['water'] = true,
|
|
['grass-1'] = true,
|
|
['grass-2'] = true,
|
|
['grass-3'] = true,
|
|
['water'] = true,
|
|
['deepwater'] = true
|
|
}
|
|
|
|
local function get_moisture(position)
|
|
local moisture = get_noise('oasis', position, storage.desert_oasis_seed)
|
|
moisture = moisture * 128
|
|
moisture = math.round(moisture, 1)
|
|
return moisture
|
|
end
|
|
|
|
local function moisture_meter(player, moisture)
|
|
local moisture_meter = player.gui.top.moisture_meter
|
|
|
|
if not moisture_meter then
|
|
moisture_meter = player.gui.top.add({ type = 'frame', name = 'moisture_meter' })
|
|
moisture_meter.style.padding = 3
|
|
|
|
local label = moisture_meter.add({ type = 'label', caption = 'Moisture Meter:' })
|
|
label.style.font = 'heading-2'
|
|
label.style.font_color = { 0, 150, 0 }
|
|
local label = moisture_meter.add({ type = 'label', caption = 0 })
|
|
label.style.font = 'heading-2'
|
|
label.style.font_color = { 175, 175, 175 }
|
|
end
|
|
|
|
moisture_meter.children[2].caption = moisture
|
|
end
|
|
|
|
local function draw_oasis(surface, left_top, seed)
|
|
local tiles = {}
|
|
local size_of_tiles = 0
|
|
local entities = {}
|
|
local size_of_entities = 0
|
|
local left_top_x = left_top.x
|
|
local left_top_y = left_top.y
|
|
|
|
for x = 0, 31, 1 do
|
|
for y = 0, 31, 1 do
|
|
local position = { x = left_top_x + x, y = left_top_y + y }
|
|
local noise = get_noise('oasis', position, seed)
|
|
if noise >= oasis_start then
|
|
if noise > water_start or noise > oasis_start + 0.035 and get_noise('cave_ponds', position, seed) > 0.72 then
|
|
size_of_tiles = size_of_tiles + 1
|
|
|
|
if noise > 0.85 then
|
|
tiles[size_of_tiles] = { name = 'deepwater', position = position }
|
|
else
|
|
tiles[size_of_tiles] = { name = 'water', position = position }
|
|
end
|
|
|
|
if math_random(1, 64) == 1 then
|
|
size_of_entities = size_of_entities + 1
|
|
entities[size_of_entities] = { name = 'fish', position = position }
|
|
end
|
|
else
|
|
size_of_tiles = size_of_tiles + 1
|
|
tiles[size_of_tiles] = { name = 'grass-' .. math_floor(noise * 32) % 3 + 1, position = position }
|
|
|
|
for _, cliff in pairs(surface.find_entities_filtered({ type = 'cliff', position = position })) do
|
|
cliff.destroy()
|
|
end
|
|
|
|
if math_random(1, 12) == 1 and surface.can_place_entity({ name = 'coal', position = position, amount = 1 }) then
|
|
size_of_entities = size_of_entities + 1
|
|
if math_abs(get_noise('n3', position, seed)) > 0.50 then
|
|
entities[size_of_entities] = { name = trees[math_floor(get_noise('n2', position, seed) * 9) % 6 + 1], position = position }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
surface.set_tiles(tiles, true)
|
|
|
|
for _, entity in pairs(entities) do
|
|
if surface.can_place_entity(entity) then
|
|
surface.create_entity(entity)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function on_chunk_generated(event)
|
|
local surface = event.surface
|
|
if surface.name ~= 'desert_oasis' then
|
|
return
|
|
end
|
|
local seed = storage.desert_oasis_seed
|
|
local left_top = event.area.left_top
|
|
|
|
for _, entity in pairs(surface.find_entities_filtered({ area = event.area, type = 'resource' })) do
|
|
if get_noise('oasis', entity.position, seed) <= oasis_start then
|
|
entity.destroy()
|
|
else
|
|
if prototypes.item[entity.name] then
|
|
surface.create_entity(
|
|
{ name = entity.name, position = entity.position, amount = math_random(200, 300) + math.sqrt(entity.position.x ^ 2 + entity.position.y ^ 2) * 0.65 }
|
|
)
|
|
entity.destroy()
|
|
end
|
|
end
|
|
end
|
|
|
|
for _, entity in pairs(surface.find_entities_filtered({ area = event.area, force = 'enemy' })) do
|
|
if get_noise('oasis', entity.position, seed) > -0.25 then
|
|
surface.destroy_decoratives(
|
|
{
|
|
area = { { entity.position.x - 10, entity.position.y - 10 }, { entity.position.x + 10, entity.position.y + 10 } },
|
|
name = { 'enemy-decal', 'enemy-decal-transparent', 'worms-decal', 'shroom-decal', 'lichen-decal', 'light-mud-decal' }
|
|
}
|
|
)
|
|
entity.destroy()
|
|
end
|
|
end
|
|
|
|
local noise = get_noise('oasis', left_top, seed)
|
|
if noise > oasis_start - 0.35 then
|
|
draw_oasis(surface, left_top, seed)
|
|
return
|
|
end
|
|
end
|
|
|
|
local function on_init()
|
|
if game.surfaces['desert_oasis'] then
|
|
return
|
|
end
|
|
|
|
local T = Map_info.Pop_info()
|
|
T.localised_category = 'desert_oasis'
|
|
T.main_caption_color = { r = 170, g = 170, b = 0 }
|
|
T.sub_caption_color = { r = 120, g = 120, b = 0 }
|
|
|
|
local map_gen_settings = {
|
|
water = 0.0,
|
|
property_expression_names = {
|
|
temperature = 50,
|
|
moisture = 0
|
|
},
|
|
starting_area = 1,
|
|
terrain_segmentation = 0.1,
|
|
cliff_settings = { cliff_elevation_interval = 8, cliff_elevation_0 = 8 },
|
|
autoplace_controls = {
|
|
['coal'] = { frequency = 23, size = 0.5, richness = 0.5 },
|
|
['stone'] = { frequency = 20, size = 0.5, richness = 0.5 },
|
|
['copper-ore'] = { frequency = 25, size = 0.5, richness = 0.5 },
|
|
['iron-ore'] = { frequency = 35, size = 0.5, richness = 0.5 },
|
|
['uranium-ore'] = { frequency = 20, size = 0.5, richness = 0.5 },
|
|
['crude-oil'] = { frequency = 50, size = 0.55, richness = 1 },
|
|
['trees'] = { frequency = 0.75, size = 0.75, richness = 0.1 },
|
|
['enemy-base'] = { frequency = 15, size = 1, richness = 1 }
|
|
}
|
|
}
|
|
|
|
storage.desert_oasis_seed = 0
|
|
local noise
|
|
local seed = 0
|
|
local position = { x = 0, y = 0 }
|
|
for _ = 1, 1024 ^ 2, 1 do
|
|
seed = math_random(1, 999999999)
|
|
noise = get_noise('oasis', position, seed)
|
|
if noise > 0.76 then
|
|
storage.desert_oasis_seed = seed
|
|
break
|
|
end
|
|
end
|
|
|
|
game.create_surface('desert_oasis', map_gen_settings)
|
|
|
|
local surface = game.surfaces['desert_oasis']
|
|
surface.request_to_generate_chunks({ 0, 0 }, 5)
|
|
surface.force_generate_chunk_requests()
|
|
|
|
local force = game.forces.player
|
|
force.technologies['landfill'].enabled = false
|
|
force.technologies['cliff-explosives'].enabled = false
|
|
end
|
|
|
|
local type_whitelist = {
|
|
['artillery-wagon'] = true,
|
|
['car'] = true,
|
|
['spider-vehicle'] = true,
|
|
['cargo-wagon'] = true,
|
|
['construction-robot'] = true,
|
|
['entity-ghost'] = true,
|
|
['fluid-wagon'] = true,
|
|
['heat-pipe'] = true,
|
|
['locomotive'] = true,
|
|
['logistic-robot'] = true,
|
|
['rail-chain-signal'] = true,
|
|
['rail-signal'] = true,
|
|
['curved-rail'] = true,
|
|
['straight-rail'] = true,
|
|
['train-stop'] = true
|
|
}
|
|
|
|
local function deny_building(event)
|
|
local entity = event.entity
|
|
if not entity.valid then
|
|
return
|
|
end
|
|
|
|
if type_whitelist[event.entity.type] then
|
|
return
|
|
end
|
|
|
|
if save_tiles[entity.surface.get_tile(entity.position).name] then
|
|
return
|
|
end
|
|
|
|
if event.player_index then
|
|
game.players[event.player_index].insert({ name = entity.name, count = 1 })
|
|
else
|
|
local inventory = event.robot.get_inventory(defines.inventory.robot_cargo)
|
|
inventory.insert({ name = entity.name, count = 1 })
|
|
end
|
|
|
|
event.entity.surface.create_entity(
|
|
{
|
|
name = 'flying-text',
|
|
position = entity.position,
|
|
text = 'Can not be built in the sands!',
|
|
color = { r = 0.98, g = 0.66, b = 0.22 }
|
|
}
|
|
)
|
|
|
|
entity.destroy()
|
|
end
|
|
|
|
local function on_built_entity(event)
|
|
deny_building(event)
|
|
end
|
|
|
|
local function on_robot_built_entity(event)
|
|
deny_building(event)
|
|
end
|
|
|
|
local function deny_tile_building(surface, inventory, tiles, tile)
|
|
for _, t in pairs(tiles) do
|
|
if not save_tiles[t.old_tile.name] then
|
|
surface.set_tiles({ { name = t.old_tile.name, position = t.position } }, true)
|
|
if prototypes.item[tile.name] then
|
|
inventory.insert({ name = tile.name, count = 1 })
|
|
else
|
|
if tile_to_item[tile.name] then
|
|
inventory.insert({ name = tile_to_item[tile.name], count = 1 })
|
|
else
|
|
inventory.insert({ name = 'stone-brick', count = 1 })
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function on_player_built_tile(event)
|
|
local player = game.players[event.player_index]
|
|
deny_tile_building(player.surface, player, event.tiles, event.tile)
|
|
end
|
|
|
|
local function on_robot_built_tile(event)
|
|
deny_tile_building(event.robot.surface, event.robot.get_inventory(defines.inventory.robot_cargo), event.tiles, event.tile)
|
|
end
|
|
|
|
local function on_player_joined_game(event)
|
|
local player = game.players[event.player_index]
|
|
if player.online_time == 0 then
|
|
player.insert({ name = 'raw-fish', count = 3 })
|
|
player.insert({ name = 'grenade', count = 1 })
|
|
player.insert({ name = 'iron-plate', count = 16 })
|
|
player.insert({ name = 'iron-gear-wheel', count = 8 })
|
|
player.insert({ name = 'stone', count = 5 })
|
|
player.insert({ name = 'pistol', count = 1 })
|
|
player.insert({ name = 'firearm-magazine', count = 16 })
|
|
player.teleport(game.surfaces['desert_oasis'].find_non_colliding_position('character', { 64, 64 }, 50, 0.5), 'desert_oasis')
|
|
end
|
|
|
|
if game.tick > 0 then
|
|
return
|
|
end
|
|
local p = game.surfaces['desert_oasis'].find_non_colliding_position('stone', { 80, 80 }, 50, 0.5)
|
|
if not p then
|
|
return
|
|
end
|
|
local e = game.surfaces.desert_oasis.create_entity({ name = 'crash-site-spaceship', position = p, force = 'player', create_build_effect_smoke = false })
|
|
e.insert({ name = 'repair-pack', count = 2 })
|
|
e.insert({ name = 'water-barrel', count = 5 })
|
|
e.minable = false
|
|
end
|
|
|
|
local function on_player_changed_position(event)
|
|
if math_random(1, 4) ~= 1 then
|
|
return
|
|
end
|
|
local player = game.players[event.player_index]
|
|
|
|
local moisture = get_moisture(player.position)
|
|
moisture_meter(player, moisture)
|
|
|
|
if not player.character then
|
|
return
|
|
end
|
|
if not player.character.valid then
|
|
return
|
|
end
|
|
if player.vehicle then
|
|
return
|
|
end
|
|
|
|
if save_tiles[player.surface.get_tile(player.position).name] then
|
|
return
|
|
end
|
|
|
|
if math_random(1, 64) == 1 then
|
|
player.surface.create_entity({ name = 'fire-flame', position = player.position })
|
|
end
|
|
|
|
player.character.health = player.character.health - (sand_damage - moisture) * 0.60
|
|
if player.character.health == 0 then
|
|
player.character.die()
|
|
end
|
|
end
|
|
|
|
local Event = require 'utils.event'
|
|
Event.on_init(on_init)
|
|
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_robot_built_entity, on_robot_built_entity)
|
|
Event.add(defines.events.on_built_entity, on_built_entity)
|
|
Event.add(defines.events.on_player_joined_game, on_player_joined_game)
|
|
Event.add(defines.events.on_player_changed_position, on_player_changed_position)
|
|
Event.add(defines.events.on_chunk_generated, on_chunk_generated)
|