mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-24 03:47:58 +02:00
668 lines
23 KiB
Lua
668 lines
23 KiB
Lua
-- modules
|
|
require 'maps.lumberjack.player_list'
|
|
require 'maps.lumberjack.comfylatron'
|
|
require 'maps.lumberjack.commands'
|
|
require 'maps.lumberjack.corpse_util'
|
|
|
|
require 'on_tick_schedule'
|
|
require 'modules.dynamic_landfill'
|
|
require 'modules.shotgun_buff'
|
|
require 'modules.burden'
|
|
require 'modules.rocks_heal_over_time'
|
|
require 'modules.no_deconstruction_of_neutral_entities'
|
|
require 'modules.flamethrower_nerf'
|
|
require 'modules.rocks_yield_ore_veins'
|
|
require 'modules.spawners_contain_biters'
|
|
require 'modules.biters_yield_coins'
|
|
require 'modules.biter_noms_you'
|
|
require 'modules.wave_defense.main'
|
|
require 'modules.admins_operate_biters'
|
|
require 'modules.pistol_buffs'
|
|
|
|
local Difficulty = require 'modules.difficulty_vote'
|
|
local Server = require 'utils.server'
|
|
local Explosives = require 'modules.explosives'
|
|
local Color = require 'utils.color_presets'
|
|
local Entities = require 'maps.lumberjack.entities'
|
|
local update_gui = require 'maps.lumberjack.gui'
|
|
local ICW = require 'maps.lumberjack.icw.main'
|
|
local WD = require 'modules.wave_defense.table'
|
|
local Map = require 'modules.map_info'
|
|
local RPG = require 'maps.lumberjack.rpg'
|
|
local Reset = require 'maps.lumberjack.soft_reset'
|
|
local Terrain = require 'maps.lumberjack.terrain'
|
|
local Event = require 'utils.event'
|
|
local WPT = require 'maps.lumberjack.table'
|
|
local Locomotive = require 'maps.lumberjack.locomotive'.locomotive_spawn
|
|
local render_train_hp = require 'maps.lumberjack.locomotive'.render_train_hp
|
|
local Score = require 'comfy_panel.score'
|
|
local Poll = require 'comfy_panel.poll'
|
|
local Collapse = require 'modules.collapse'
|
|
local Balance = require 'maps.lumberjack.balance'
|
|
local shape = require 'maps.lumberjack.terrain'.heavy_functions
|
|
local Generate = require 'maps.lumberjack.generate'
|
|
local Task = require 'utils.task'
|
|
|
|
local Public = {}
|
|
local math_random = math.random
|
|
|
|
WPT.init({train_reveal = false, energy_shared = true, reveal_normally = true})
|
|
|
|
local starting_items = {['pistol'] = 1, ['firearm-magazine'] = 16, ['wood'] = 4, ['rail'] = 16, ['raw-fish'] = 2}
|
|
|
|
local grandmaster = '[color=blue]Grandmaster:[/color]'
|
|
|
|
local function create_forces_and_disable_tech()
|
|
if not game.forces.defenders then
|
|
game.create_force('defenders')
|
|
end
|
|
if not game.forces.lumber_defense then
|
|
game.create_force('lumber_defense')
|
|
end
|
|
game.forces.defenders.share_chart = false
|
|
game.forces.player.set_friend('defenders', true)
|
|
game.forces.player.set_friend('lumber_defense', false)
|
|
game.forces.lumber_defense.set_friend('player', false)
|
|
game.forces.lumber_defense.set_friend('enemy', true)
|
|
game.forces.enemy.set_friend('defenders', true)
|
|
game.forces.enemy.set_friend('lumber_defense', true)
|
|
game.forces.defenders.set_friend('player', true)
|
|
game.forces.defenders.set_friend('enemy', true)
|
|
game.forces.defenders.share_chart = false
|
|
game.forces.player.technologies['landfill'].enabled = false
|
|
game.forces.player.technologies['optics'].researched = true
|
|
game.forces.player.technologies['land-mine'].enabled = false
|
|
Balance.init_enemy_weapon_damage()
|
|
end
|
|
|
|
local function set_difficulty()
|
|
local Diff = Difficulty.get()
|
|
local wave_defense_table = WD.get_table()
|
|
local player_count = #game.connected_players
|
|
if not Diff.difficulty_vote_value then
|
|
Diff.difficulty_vote_value = 0.1
|
|
end
|
|
|
|
wave_defense_table.max_active_biters = 768 + player_count * (90 * Diff.difficulty_vote_value)
|
|
|
|
-- threat gain / wave
|
|
wave_defense_table.threat_gain_multiplier = 1.2 + player_count * Diff.difficulty_vote_value * 0.1
|
|
|
|
local amount = player_count * 0.25 + 2
|
|
amount = math.floor(amount)
|
|
if amount > 8 then
|
|
amount = 8
|
|
end
|
|
Collapse.set_amount(amount)
|
|
|
|
wave_defense_table.wave_interval = 3600
|
|
end
|
|
|
|
local function render_direction(surface)
|
|
rendering.draw_text {
|
|
text = 'Welcome to Lumberjack!',
|
|
surface = surface,
|
|
target = {-0, 10},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
|
|
rendering.draw_text {
|
|
text = '▼',
|
|
surface = surface,
|
|
target = {-0, 20},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
|
|
rendering.draw_text {
|
|
text = '▼',
|
|
surface = surface,
|
|
target = {-0, 30},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
rendering.draw_text {
|
|
text = '▼',
|
|
surface = surface,
|
|
target = {-0, 40},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
rendering.draw_text {
|
|
text = '▼',
|
|
surface = surface,
|
|
target = {-0, 50},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
rendering.draw_text {
|
|
text = '▼',
|
|
surface = surface,
|
|
target = {-0, 60},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
rendering.draw_text {
|
|
text = 'Biters will attack this area.',
|
|
surface = surface,
|
|
target = {-0, 70},
|
|
color = {r = 0.98, g = 0.66, b = 0.22},
|
|
scale = 3,
|
|
font = 'heading-1',
|
|
alignment = 'center',
|
|
scale_with_zoom = false
|
|
}
|
|
|
|
surface.create_entity({name = 'electric-beam', position = {-196, 74}, source = {-196, 74}, target = {196, 74}})
|
|
surface.create_entity({name = 'electric-beam', position = {-196, 74}, source = {-196, 74}, target = {196, 74}})
|
|
end
|
|
|
|
function Public.reset_map()
|
|
local this = WPT.get_table()
|
|
local wave_defense_table = WD.get_table()
|
|
local get_score = Score.get_table()
|
|
local Diff = Difficulty.get()
|
|
local map_gen_settings = {
|
|
['seed'] = math_random(10000, 99999),
|
|
['water'] = 0.001,
|
|
['starting_area'] = 1,
|
|
['cliff_settings'] = {cliff_elevation_interval = 0, cliff_elevation_0 = 0},
|
|
['default_enable_all_autoplace_controls'] = true,
|
|
['autoplace_settings'] = {
|
|
['entity'] = {treat_missing_as_default = false},
|
|
['tile'] = {treat_missing_as_default = true},
|
|
['decorative'] = {treat_missing_as_default = true}
|
|
}
|
|
}
|
|
|
|
if not this.active_surface_index then
|
|
this.active_surface_index = game.create_surface('lumberjack', map_gen_settings).index
|
|
this.active_surface = game.surfaces[this.active_surface_index]
|
|
else
|
|
game.forces.player.set_spawn_position({0, 25}, game.surfaces[this.active_surface_index])
|
|
this.active_surface_index =
|
|
Reset.soft_reset_map(game.surfaces[this.active_surface_index], map_gen_settings, starting_items).index
|
|
this.active_surface = game.surfaces[this.active_surface_index]
|
|
end
|
|
|
|
Poll.reset()
|
|
ICW.reset()
|
|
game.reset_time_played()
|
|
WPT.reset_table()
|
|
wave_defense_table.math = 8
|
|
if not this.train_reveal and not this.reveal_normally then
|
|
this.revealed_spawn = game.tick + 100
|
|
end
|
|
|
|
create_forces_and_disable_tech()
|
|
|
|
local surface = game.surfaces[this.active_surface_index]
|
|
|
|
surface.request_to_generate_chunks({0, 0}, 0.5)
|
|
surface.force_generate_chunk_requests()
|
|
|
|
local p = surface.find_non_colliding_position('character-corpse', {2, 21}, 2, 2)
|
|
surface.create_entity({name = 'character-corpse', position = p})
|
|
|
|
game.forces.player.set_spawn_position({0, 21}, surface)
|
|
|
|
global.bad_fire_history = {}
|
|
global.friendly_fire_history = {}
|
|
global.landfill_history = {}
|
|
global.mining_history = {}
|
|
get_score.score_table = {}
|
|
Diff.difficulty_poll_closing_timeout = game.tick + 90000
|
|
Diff.difficulty_player_votes = {}
|
|
|
|
game.difficulty_settings.technology_price_multiplier = 0.6
|
|
|
|
Collapse.set_kill_entities(false)
|
|
Collapse.set_speed(8)
|
|
Collapse.set_amount(1)
|
|
Collapse.set_max_line_size(Terrain.level_depth)
|
|
Collapse.set_surface(surface)
|
|
Collapse.set_position({0, 162})
|
|
Collapse.set_direction('north')
|
|
Collapse.start_now(false)
|
|
|
|
surface.ticks_per_day = surface.ticks_per_day * 2
|
|
surface.daytime = 0.71
|
|
surface.brightness_visual_weights = {1, 0, 0, 0}
|
|
surface.freeze_daytime = false
|
|
surface.solar_power_multiplier = 1
|
|
this.locomotive_health = 10000
|
|
this.locomotive_max_health = 10000
|
|
this.cargo_health = 10000
|
|
this.cargo_max_health = 10000
|
|
|
|
Locomotive(surface, {x = -18, y = 25})
|
|
render_train_hp()
|
|
render_direction(surface)
|
|
RPG.rpg_reset_all_players()
|
|
|
|
WD.reset_wave_defense()
|
|
wave_defense_table.surface_index = this.active_surface_index
|
|
wave_defense_table.target = this.locomotive_cargo
|
|
wave_defense_table.nest_building_density = 32
|
|
wave_defense_table.game_lost = false
|
|
wave_defense_table.spawn_position = {x = 0, y = 100}
|
|
wave_defense_table.next_wave = game.tick + 3600 * 25
|
|
|
|
set_difficulty()
|
|
|
|
local surfaces = {
|
|
[surface.name] = shape
|
|
}
|
|
Generate.init({surfaces = surfaces, regen_decoratives = true, tiles_per_tick = 32})
|
|
Task.reset_queue()
|
|
Task.start_queue()
|
|
Task.set_queue_speed(10)
|
|
|
|
this.chunk_load_tick = game.tick + 500
|
|
end
|
|
|
|
local function on_load()
|
|
local this = WPT.get_table()
|
|
|
|
local surfaces = {
|
|
[this.active_surface.name] = shape
|
|
}
|
|
Generate.init({surfaces = surfaces, regen_decoratives = true, tiles_per_tick = 32})
|
|
Generate.register()
|
|
Task.start_queue()
|
|
end
|
|
|
|
local function on_player_changed_position(event)
|
|
local this = WPT.get_table()
|
|
local player = game.players[event.player_index]
|
|
local map_name = 'lumberjack'
|
|
|
|
if string.sub(player.surface.name, 0, #map_name) ~= map_name then
|
|
return
|
|
end
|
|
|
|
local position = player.position
|
|
local surface = game.surfaces[this.active_surface_index]
|
|
if position.x >= Terrain.level_depth * 0.5 then
|
|
return
|
|
end
|
|
if position.x < Terrain.level_depth * -0.5 then
|
|
return
|
|
end
|
|
|
|
if
|
|
not this.train_reveal and not this.reveal_normally or
|
|
this.players[player.index].start_tick and game.tick - this.players[player.index].start_tick < 6400
|
|
then
|
|
if position.y < 5 then
|
|
Terrain.reveal_player(player)
|
|
end
|
|
end
|
|
if position.y >= 74 then
|
|
player.teleport({position.x, position.y - 1}, surface)
|
|
player.print(grandmaster .. ' Forcefield does not approve.', {r = 0.98, g = 0.66, b = 0.22})
|
|
if player.character then
|
|
player.character.health = player.character.health - 5
|
|
player.character.surface.create_entity({name = 'water-splash', position = position})
|
|
if player.character.health <= 0 then
|
|
player.character.die('enemy')
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function on_player_joined_game(event)
|
|
local this = WPT.get_table()
|
|
local surface = game.surfaces[this.active_surface_index]
|
|
local player = game.players[event.player_index]
|
|
|
|
set_difficulty(event)
|
|
|
|
if not this.players then
|
|
this.players = {}
|
|
end
|
|
|
|
if not this.players[player.index] then
|
|
this.players[player.index] = {
|
|
first_join = false,
|
|
data = {}
|
|
}
|
|
end
|
|
|
|
if not this.players[player.index].first_join then
|
|
player.print(grandmaster .. ' Greetings, newly joined ' .. player.name .. '!', {r = 0.98, g = 0.66, b = 0.22})
|
|
player.print(grandmaster .. ' Please read the map info.', {r = 0.98, g = 0.66, b = 0.22})
|
|
this.players[player.index].first_join = true
|
|
end
|
|
|
|
if player.surface.index ~= this.active_surface_index then
|
|
player.teleport(
|
|
surface.find_non_colliding_position('character', game.forces.player.get_spawn_position(surface), 3, 0, 5),
|
|
surface
|
|
)
|
|
for item, amount in pairs(starting_items) do
|
|
player.insert({name = item, count = amount})
|
|
end
|
|
end
|
|
end
|
|
|
|
local function on_player_left_game()
|
|
set_difficulty()
|
|
end
|
|
|
|
local function on_pre_player_left_game(event)
|
|
local this = WPT.get_table()
|
|
local player = game.players[event.player_index]
|
|
if player.controller_type == defines.controllers.editor then
|
|
player.toggle_map_editor()
|
|
end
|
|
if player.character then
|
|
this.offline_players[#this.offline_players + 1] = {index = event.player_index, tick = game.tick}
|
|
end
|
|
end
|
|
|
|
local function offline_players()
|
|
local this = WPT.get_table()
|
|
local players = this.offline_players
|
|
local surface = game.surfaces[this.active_surface_index]
|
|
if #players > 0 then
|
|
local later = {}
|
|
for i = 1, #players, 1 do
|
|
if players[i] and game.players[players[i].index] and game.players[players[i].index].connected then
|
|
players[i] = nil
|
|
else
|
|
if players[i] and players[i].tick < game.tick - 54000 then
|
|
local player_inv = {}
|
|
local items = {}
|
|
player_inv[1] = game.players[players[i].index].get_inventory(defines.inventory.character_main)
|
|
player_inv[2] = game.players[players[i].index].get_inventory(defines.inventory.character_armor)
|
|
player_inv[3] = game.players[players[i].index].get_inventory(defines.inventory.character_guns)
|
|
player_inv[4] = game.players[players[i].index].get_inventory(defines.inventory.character_ammo)
|
|
player_inv[5] = game.players[players[i].index].get_inventory(defines.inventory.character_trash)
|
|
local e =
|
|
surface.create_entity(
|
|
{
|
|
name = 'character',
|
|
position = game.forces.player.get_spawn_position(surface),
|
|
force = 'neutral'
|
|
}
|
|
)
|
|
local inv = e.get_inventory(defines.inventory.character_main)
|
|
for ii = 1, 5, 1 do
|
|
if player_inv[ii].valid then
|
|
for iii = 1, #player_inv[ii], 1 do
|
|
if player_inv[ii][iii].valid then
|
|
items[#items + 1] = player_inv[ii][iii]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if #items > 0 then
|
|
for item = 1, #items, 1 do
|
|
if items[item].valid then
|
|
inv.insert(items[item])
|
|
end
|
|
end
|
|
game.print({'chronosphere.message_accident'}, {r = 0.98, g = 0.66, b = 0.22})
|
|
e.die('neutral')
|
|
else
|
|
e.destroy()
|
|
end
|
|
|
|
for ii = 1, 5, 1 do
|
|
if player_inv[ii].valid then
|
|
player_inv[ii].clear()
|
|
end
|
|
end
|
|
players[i] = nil
|
|
else
|
|
later[#later + 1] = players[i]
|
|
end
|
|
end
|
|
end
|
|
players = {}
|
|
if #later > 0 then
|
|
for i = 1, #later, 1 do
|
|
players[#players + 1] = later[i]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function disable_recipes()
|
|
local force = game.forces.player
|
|
force.recipes['cargo-wagon'].enabled = false
|
|
force.recipes['fluid-wagon'].enabled = false
|
|
force.recipes['artillery-wagon'].enabled = false
|
|
force.recipes['locomotive'].enabled = false
|
|
force.recipes['pistol'].enabled = false
|
|
end
|
|
|
|
local function on_research_finished(event)
|
|
disable_recipes()
|
|
event.research.force.character_inventory_slots_bonus = game.forces.player.mining_drill_productivity_bonus * 50 -- +5 Slots / level
|
|
local mining_speed_bonus = game.forces.player.mining_drill_productivity_bonus * 5 -- +50% speed / level
|
|
if event.research.force.technologies['steel-axe'].researched then
|
|
mining_speed_bonus = mining_speed_bonus + 0.5
|
|
end -- +50% speed for steel-axe research
|
|
event.research.force.manual_mining_speed_modifier = mining_speed_bonus
|
|
end
|
|
|
|
local function darkness(data)
|
|
local rnd = math.random
|
|
local this = data.this
|
|
local surface = data.surface
|
|
if rnd(1, 24) == 1 then
|
|
if not this.freeze_daytime then
|
|
return
|
|
end
|
|
game.print(grandmaster .. ' Sunlight, finally!', {r = 0.98, g = 0.66, b = 0.22})
|
|
surface.min_brightness = 1
|
|
surface.brightness_visual_weights = {1, 0, 0, 0}
|
|
surface.daytime = 1
|
|
surface.freeze_daytime = false
|
|
surface.solar_power_multiplier = 1
|
|
this.freeze_daytime = false
|
|
return
|
|
elseif rnd(1, 64) == 1 then
|
|
if this.freeze_daytime then
|
|
return
|
|
end
|
|
game.print(grandmaster .. ' Darkness has surrounded us!', {r = 0.98, g = 0.66, b = 0.22})
|
|
game.print(grandmaster .. ' Builds some lamps!', {r = 0.98, g = 0.66, b = 0.22})
|
|
surface.min_brightness = 0
|
|
surface.brightness_visual_weights = {0.90, 0.90, 0.90}
|
|
surface.daytime = 0.42
|
|
surface.freeze_daytime = true
|
|
surface.solar_power_multiplier = 0
|
|
this.freeze_daytime = true
|
|
return
|
|
end
|
|
end
|
|
|
|
local function transfer_pollution(data)
|
|
local Diff = Difficulty.get()
|
|
local surface = data.loco_surface
|
|
local this = data.this
|
|
if not surface then
|
|
return
|
|
end
|
|
local pollution = surface.get_total_pollution() * (3 / (4 / 3 + 1)) * Diff.difficulty_vote_value
|
|
game.surfaces[this.active_surface_index].pollute(this.locomotive.position, pollution)
|
|
surface.clear_pollution()
|
|
end
|
|
|
|
local tick_minute_functions = {
|
|
[300 * 3 + 30 * 6] = darkness,
|
|
[300 * 3 + 30 * 6] = transfer_pollution
|
|
}
|
|
|
|
local on_tick = function()
|
|
local this = WPT.get_table()
|
|
local surface = game.surfaces[this.active_surface_index]
|
|
local wave_defense_table = WD.get_table()
|
|
local tick = game.tick
|
|
local status = Collapse.start_now()
|
|
local key = tick % 3600
|
|
local unit_surface = this.locomotive.unit_number
|
|
local icw_table = ICW.get_table()
|
|
if not this.locomotive.valid then
|
|
Entities.loco_died()
|
|
end
|
|
local data = {
|
|
this = this,
|
|
surface = surface,
|
|
loco_surface = game.surfaces[icw_table.wagons[unit_surface].surface.index]
|
|
}
|
|
|
|
if status == true then
|
|
goto continue
|
|
end
|
|
if
|
|
this.left_top.y % Terrain.level_depth == 0 and this.left_top.y < 0 and
|
|
this.left_top.y > Terrain.level_depth * -10
|
|
then
|
|
if not Collapse.start_now() then
|
|
Collapse.start_now(true)
|
|
end
|
|
end
|
|
::continue::
|
|
if game.tick % 30 == 0 then
|
|
for _, player in pairs(game.connected_players) do
|
|
update_gui(player)
|
|
end
|
|
|
|
if game.tick % 1800 == 0 then
|
|
local position = surface.find_non_colliding_position('stone-furnace', Collapse.get_position(), 128, 1)
|
|
if position then
|
|
wave_defense_table.spawn_position = position
|
|
end
|
|
offline_players()
|
|
Entities.set_scores()
|
|
end
|
|
end
|
|
if tick_minute_functions[key] then
|
|
tick_minute_functions[key](data)
|
|
end
|
|
|
|
if this.game_reset_tick then
|
|
if this.game_reset_tick < game.tick then
|
|
if not this.disable_reset then
|
|
this.game_reset_tick = nil
|
|
Public.reset_map()
|
|
else
|
|
if not this.reset_the_game then
|
|
game.print('Auto reset is disabled. Server is shutting down!', {r = 0.22, g = 0.88, b = 0.22})
|
|
local message = 'Auto reset is disabled. Server is shutting down!'
|
|
Server.to_discord_bold(table.concat {'*** ', message, ' ***'})
|
|
Server.stop_scenario()
|
|
this.reset_the_game = true
|
|
end
|
|
end
|
|
end
|
|
return
|
|
end
|
|
|
|
if this.chunk_load_tick then
|
|
if this.chunk_load_tick < game.tick then
|
|
this.chunk_load_tick = nil
|
|
Task.set_queue_speed(1)
|
|
end
|
|
end
|
|
end
|
|
|
|
local on_init = function()
|
|
local this = WPT.get_table()
|
|
Public.reset_map()
|
|
|
|
local tooltip = {
|
|
[1] = 'something',
|
|
[2] = 'something else',
|
|
[3] = 'something else else',
|
|
[4] = 'something else else else',
|
|
[5] = 'something else else else else',
|
|
[6] = 'something else else else else else',
|
|
[7] = 'something else else else else else else'
|
|
}
|
|
|
|
Difficulty:set_tooltip(tooltip)
|
|
|
|
global.custom_highscore.description = 'Wagon distance reached:'
|
|
|
|
this.rocks_yield_ore_maximum_amount = 500
|
|
this.type_modifier = 1
|
|
this.rocks_yield_ore_base_amount = 50
|
|
this.rocks_yield_ore_distance_modifier = 0.025
|
|
|
|
local T = Map.Pop_info()
|
|
T.main_caption = 'L u m b e r j a c k '
|
|
T.sub_caption = 'Chop the wood, toss the wood, save the train, die again!'
|
|
T.text =
|
|
table.concat(
|
|
{
|
|
'Welcome lumberlover!\n',
|
|
'\n',
|
|
'The biters have catched the scent of fish in the cargo wagon.\n',
|
|
'Guide the choo and protect it for as long as possible!\n',
|
|
'This will not be an easy task however,\n',
|
|
'since their strength and numbers increase over time.\n',
|
|
'\n',
|
|
'Delve deep for greater treasures, but also face increased dangers.\n',
|
|
'Mining productivity research, will overhaul your mining equipment,\n',
|
|
'reinforcing your pickaxe as well as increasing the size of your backpack.\n',
|
|
'\n',
|
|
"We've also noticed that solar eclipse occuring, \n",
|
|
'we have yet to solve this mystery\n',
|
|
'\n',
|
|
'Good luck, over and out!'
|
|
}
|
|
)
|
|
T.main_caption_color = {r = 150, g = 150, b = 0}
|
|
T.sub_caption_color = {r = 0, g = 150, b = 0}
|
|
|
|
local mgs = game.surfaces['nauvis'].map_gen_settings
|
|
mgs.width = 16
|
|
mgs.height = 16
|
|
game.surfaces['nauvis'].map_gen_settings = mgs
|
|
game.surfaces['nauvis'].clear()
|
|
|
|
Explosives.set_destructible_tile('out-of-map', 1500)
|
|
Explosives.set_destructible_tile('water', 1000)
|
|
Explosives.set_destructible_tile('water-green', 1000)
|
|
Explosives.set_destructible_tile('deepwater-green', 1000)
|
|
Explosives.set_destructible_tile('deepwater', 1000)
|
|
Explosives.set_destructible_tile('water-shallow', 1000)
|
|
|
|
Generate.register()
|
|
end
|
|
|
|
Event.on_nth_tick(10, on_tick)
|
|
Event.on_init(on_init)
|
|
Event.on_load(on_load)
|
|
Event.add(defines.events.on_player_joined_game, on_player_joined_game)
|
|
Event.add(defines.events.on_player_left_game, on_player_left_game)
|
|
Event.add(defines.events.on_player_changed_position, on_player_changed_position)
|
|
Event.add(defines.events.on_research_finished, on_research_finished)
|
|
Event.add(defines.events.on_pre_player_left_game, on_pre_player_left_game)
|
|
|
|
return Public
|