1
0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-14 10:13:13 +02:00
RedMew/map_gen/maps/quadrants/scenario.lua
2019-03-03 16:40:58 +01:00

443 lines
14 KiB
Lua

require 'map_gen.maps.quadrants.switch_team'
require 'map_gen.maps.quadrants.restrict_placement'
require 'map_gen.maps.quadrants.force_sync'
require 'map_gen.maps.quadrants.train_crossing'
local b = require('map_gen.shared.builders')
local Retailer = require('features.retailer')
local market_items = require 'resources.market_items'
local RS = require 'map_gen.shared.redmew_surface'
local Event = require 'utils.event'
local ScenarioInfo = require 'features.gui.info'
local Recipes = require 'map_gen.maps.quadrants.enabled_recipes'
local CompiHandler = require 'map_gen.maps.quadrants.compilatron_handler'
local Token = require 'utils.token'
local Task = require 'utils.task'
local abs = math.abs
local round = math.round
local redmew_config = global.config
ScenarioInfo.set_map_name('Quadrants')
ScenarioInfo.set_map_description('Take control over an area and work together as a region!')
ScenarioInfo.add_map_extra_info(
[[
This map is split in four quadrants.
Each quadrant has a main objective.
The following quadrants exists:
Science and Military, Intermediate and Mining,
Oil and High Tech, Logistics and Transport.
Common for all quadrants:
- Basic manufacturing and power
- Commercial super market present
- Teleportation between quadrants with empty inventory, excluding:
- Tools
- Utility Armor
- Weaponry
Science and Military
- Manages research for the entire region
- Supplies weaponry and security solutions to the entire region
Intermediate and Mining
- Only producer of steel
- High precision workers allowing for circuitry manufacturing
- Area found to have rich amount of minerals
Oil and High Tech
- Facilities for oil processing
- Facilities for nuclear handling
- Leading force in innovating products
- Rocket launch site
Logistics and Transport
- Leading force in logistical solutions
- Belt based
- Bot based
- Train based
Version: v1.0
]]
)
redmew_config.paint.enabled = false
redmew_config.player_create.starting_items = {
{name = 'iron-plate', count = 7},
{name = 'iron-gear-wheel', count = 3}
}
redmew_config.hail_hydra.enabled = true
redmew_config.hail_hydra.hydras = {
-- spitters
['small-spitter'] = {['small-worm-turret'] = {min = 0.2, max = 1}},
['medium-spitter'] = {['medium-worm-turret'] = {min = 0.2, max = 1}},
['big-spitter'] = {['big-worm-turret'] = {min = 0.2, max = 1}},
['behemoth-spitter'] = {['behemoth-worm-turret'] = {min = 0.2, max = 1}},
-- biters
['medium-biter'] = {['small-biter'] = {min = 1, max = 2}},
['big-biter'] = {['medium-biter'] = {min = 1, max = 2}},
['behemoth-biter'] = {['big-biter'] = {min = 1, max = 2}},
-- worms
['small-worm-turret'] = {['small-biter'] = {min = 1.5, max = 2.5}},
['medium-worm-turret'] = {['small-biter'] = {min = 2.5, max = 3.5}, ['medium-biter'] = {min = 1.0, max = 2}},
['big-worm-turret'] = {
['small-biter'] = {min = 2.5, max = 4.5},
['medium-biter'] = {min = 1.5, max = 2.2},
['big-biter'] = {min = 0.7, max = 1.5}
},
['behemoth-worm-turret'] = {
['small-biter'] = {min = 4.5, max = -1},
['medium-biter'] = {min = 2.5, max = 3.8},
['big-biter'] = {min = 1.2, max = 2.4},
['behemoth-biter'] = {min = 0.8, max = -1}
}
}
local function spawn_market(surface, position)
position.x = round(position.x)
position.y = round(position.y - 4)
local pos = surface.find_non_colliding_position('market', position, 10, 1)
local market = surface.create_entity({name = 'market', position = pos})
market.destructible = false
Retailer.add_market(pos.x .. 'fish_market' .. pos.y, market)
if table.size(Retailer.get_items(pos.x .. 'fish_market' .. pos.y)) == 0 then
for _, prototype in pairs(market_items) do
Retailer.set_item(pos.x .. 'fish_market' .. pos.y, prototype)
end
end
pos = surface.find_non_colliding_position('compilatron', position, 10, 1)
local compi = surface.create_entity {name = 'compilatron', position = pos, force = game.forces.neutral}
local quadrant = 'quadrant'
if pos.x > 0 then
if pos.y > 0 then
quadrant = quadrant .. '4'
else
quadrant = quadrant .. '1'
end
else
if pos.y > 0 then
quadrant = quadrant .. '3'
else
quadrant = quadrant .. '2'
end
end
CompiHandler.add_compilatron(compi, quadrant)
end
local function reset_recipes()
for _, force in pairs(game.forces) do
if (string.find(force.name, 'quadrant')) ~= nil then
for _, recipe in pairs(force.recipes) do
if not (Recipes[force.name].recipe[recipe.name] or Recipes.default.recipe[recipe.name]) then
recipe.enabled = false
end
end
end
end
end
local function on_init()
local surface = RS.get_surface()
local q1 = game.create_force('quadrant1')
q1.set_spawn_position({64, -64}, surface)
local q2 = game.create_force('quadrant2')
q2.set_spawn_position({-64, -64}, surface)
local q3 = game.create_force('quadrant3')
q3.set_spawn_position({-64, 64}, surface)
local q4 = game.create_force('quadrant4')
q4.set_spawn_position({64, 64}, surface)
reset_recipes()
for _, force in pairs(game.forces) do
if (string.find(force.name, 'quadrant')) ~= nil or force.name == 'player' then
force.share_chart = true
if force.name ~= 'quadrant1' then
force.disable_research()
end
for _, friend_force in pairs(game.forces) do
if (string.find(friend_force.name, 'quadrant')) ~= nil or friend_force.name == 'player' then
if friend_force ~= force then
force.set_friend(friend_force, true)
end
end
end
end
end
game.map_settings.enemy_evolution.time_factor = 0.0002
game.map_settings.enemy_evolution.destroy_factor = 0.0010
game.map_settings.enemy_evolution.pollution_factor = 0.0005
end
local function on_research_finished(event)
if event.research.force ~= game.forces['quadrant1'] then
return
end
for _, force in pairs(game.forces) do
if (string.find(force.name, 'quadrant')) ~= nil then
if force.name ~= 'quadrant1' then
force.technologies[event.research.name].researched = true
end
end
end
reset_recipes()
end
local callback_token
local callback
local tile_numbers = {
[-26] = {22, -22, -21, -20, -19},
[-27] = {22, -22},
[-28] = {22, -22},
[-29] = {22, -22, -21, -20, -19},
[-30] = {22, -19},
[-31] = {22, -19},
[-32] = {22, -22, -21, -20, -19},
[25] = {19, 22, -22, -21, -20, -19},
[26] = {19, 22, -19},
[27] = {19, 22, -19},
[28] = {19, 20, 21, 22, -22, -21, -20, -19},
[29] = {22, -19},
[30] = {22, -19},
[31] = {22, -22, -21, -20, -19}
}
local function spawn_compilatron()
local pos = game.surfaces[2].find_non_colliding_position('compilatron', {-0.5, -0.5}, 1.5, 0.5)
local compi = game.surfaces[2].create_entity {name = 'compilatron', position = pos, force = game.forces.neutral}
CompiHandler.add_compilatron(compi, 'spawn')
for y, x_table in pairs(tile_numbers) do
for _, x in pairs(x_table) do
game.surfaces[2].set_tiles({{name = 'lab-white', position = {x = x, y = y}}}, true)
end
end
end
local function chunk_generated()
Event.remove_removable(defines.events.on_chunk_generated, callback_token)
Task.set_timeout_in_ticks(300, callback)
end
Event.on_init(on_init)
Event.add(defines.events.on_research_finished, on_research_finished)
callback_token = Token.register(chunk_generated)
callback = Token.register(spawn_compilatron)
Event.add_removable(defines.events.on_chunk_generated, callback_token)
local function rail_create(data)
local pos = data.pos
local direction = data.direction
local rail =
game.surfaces[2].create_entity {
name = 'straight-rail',
position = pos,
force = game.forces.neutral,
direction = direction
}
if rail and rail.valid then
rail.minable = false
rail.destructible = false
end
end
local rail_callback = Token.register(rail_create)
local function quadrants(x, y)
local abs_x = abs(x) - 0.5
local abs_y = abs(y) - 0.5
if true then
local pos = {x = x, y = y}
if x > -24 and x < 24 and (y == 211.5 or y == 205.5) then
Task.set_timeout_in_ticks(300, rail_callback, {pos = pos, direction = defines.direction.east})
elseif x > -24 and x < 24 and (y == -211.5 or y == -205.5) then
Task.set_timeout_in_ticks(300, rail_callback, {pos = pos, direction = defines.direction.east})
elseif y > -24 and y < 24 and (x == 211.5 or x == 205.5) then
Task.set_timeout_in_ticks(300, rail_callback, {pos = pos, direction = defines.direction.north})
elseif y > -24 and y < 24 and (x == -211.5 or x == -205.5) then
Task.set_timeout_in_ticks(300, rail_callback, {pos = pos, direction = defines.direction.north})
end
end
if (abs_x <= 200 and abs_y <= 200) then
if game.surfaces[2].get_tile(x, y).collides_with('water-tile') then
game.surfaces[2].set_tiles({{name = 'grass-1', position = {x, y}}}, true)
end
local entities = game.surfaces[2].find_entities({{x - 0.5, y - 0.5}, {x + 0.5, y + 0.5}})
for _, entity in ipairs(entities) do
if entity and entity.valid then
if entity.name ~= 'player' and entity.name ~= 'compilatron' and entity.name ~= 'straight-rail' then
entity.destroy()
end
end
end
end
if (x < 0 and y < 0) then
if not (abs_x <= 200 and abs_y <= 200) then
local resources =
game.surfaces[2].find_entities_filtered {
area = {{x - 0.5, y - 0.5}, {x + 0.5, y + 0.5}},
type = 'resource'
}
for _, resource in pairs(resources) do
if resource.name ~= 'crude-oil' then
local amount = b.euclidean_value(1, 0.002)
resource.amount = resource.amount * amount(x, y)
end
end
end
end
if (abs_x == 132) and (abs_y == 132) then
spawn_market(RS.get_surface(), {x = x, y = y})
end
if (abs_x >= 144 and abs_x <= 176 and abs_y >= 144 and abs_y <= 176) then
game.surfaces[2].set_tiles({{name = 'water', position = {x, y}}}, true)
end
if (abs_x <= 23 or abs_y <= 23) then
-- Between quadrants create land
game.surfaces[2].set_tiles({{name = 'tutorial-grid', position = {x, y}}}, true)
game.surfaces[2].destroy_decoratives {{x - 0.5, y - 0.5}, {x + 0.5, y + 0.5}}
local entities = game.surfaces[2].find_entities({{x - 0.5, y - 0.5}, {x + 0.5, y + 0.5}})
for _, entity in ipairs(entities) do
if entity and entity.valid then
if entity.name ~= 'player' then
entity.destroy()
end
end
end
if (abs_x <= 1 and abs_y <= 1) then
if abs_x == 1 and abs_y == 1 then
return false
end
return true
end
if (abs_x <= 23 and abs_y <= 23) then
-- Around spawn, in between the quadrants
return false
end
if (abs_x < 2 or abs_y < 2) then
return false
end
return true
end
return true
end
local rectangle = b.rectangle(32, 32)
local tree_rectangle = b.rectangle(64, 16)
local tree_rectangle_1 = b.throttle_world_xy(tree_rectangle, 1, 3, 1, 3)
local tree_rectangle_2 = b.rotate(tree_rectangle_1, math.pi / 2)
local oil_rectangle = b.throttle_world_xy(tree_rectangle, 1, 5, 1, 5)
local function constant(x)
return function()
return x
end
end
local base_x = 80
local base_y = 80
local start_iron = b.resource(rectangle, 'iron-ore', constant(600))
local start_copper = b.resource(rectangle, 'copper-ore', constant(450))
local start_stone = b.resource(rectangle, 'stone', constant(150))
local start_coal = b.resource(rectangle, 'coal', constant(300))
local start_tree_1 = b.entity(tree_rectangle_1, 'tree-01')
local start_oil = b.resource(oil_rectangle, 'crude-oil', b.exponential_value(50000, 0, 1))
local start_tree_2 = b.entity(tree_rectangle_2, 'tree-01')
start_iron =
b.any(
{
b.translate(start_iron, base_x, base_y),
b.translate(start_iron, -base_x, -base_y),
b.translate(start_iron, base_x, -base_y),
b.translate(start_iron, -base_x, base_y)
}
)
base_x = base_x + 32
start_copper =
b.any(
{
b.translate(start_copper, base_x, base_y),
b.translate(start_copper, -base_x, -base_y),
b.translate(start_copper, base_x, -base_y),
b.translate(start_copper, -base_x, base_y)
}
)
base_y = base_x
start_stone =
b.any(
{
b.translate(start_stone, base_x, base_y),
b.translate(start_stone, -base_x, -base_y),
b.translate(start_stone, base_x, -base_y),
b.translate(start_stone, -base_x, base_y)
}
)
base_x = base_x - 32
start_coal =
b.any(
{
b.translate(start_coal, base_x, base_y),
b.translate(start_coal, -base_x, -base_y),
b.translate(start_coal, base_x, -base_y),
b.translate(start_coal, -base_x, base_y)
}
)
base_x = 96
base_y = 160
start_tree_1 =
b.any(
{
b.translate(start_tree_1, base_x, base_y),
b.translate(start_tree_1, -base_x, -base_y),
b.translate(start_tree_1, base_x, -base_y),
b.translate(start_oil, -base_x, base_y)
}
)
base_x = 160
base_y = 96
start_tree_2 =
b.any(
{
b.translate(start_tree_2, base_x, base_y),
b.translate(start_tree_2, -base_x, -base_y),
b.translate(start_tree_2, base_x, -base_y),
b.translate(start_tree_2, -base_x, base_y)
}
)
local map = b.apply_entities(quadrants, {start_iron, start_copper, start_stone, start_coal, start_tree_1, start_tree_2})
return map