mirror of
https://github.com/Refactorio/RedMew.git
synced 2024-12-14 10:13:13 +02:00
443 lines
14 KiB
Lua
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
|