1158 lines
42 KiB
Lua
1158 lines
42 KiB
Lua
--[[ Copyright (c) 2022 npc_strider, ickputzdirwech
|
|
* Original mod by npc_strider.
|
|
* For direct use of code or graphics, credit is appreciated and encouraged. See LICENSE.txt for more information.
|
|
* This mod may contain modified code sourced from base/core Factorio.
|
|
* This mod has been modified by ickputzdirwech.
|
|
]]
|
|
|
|
--[[ Overview of control.lua:
|
|
* Scripts for updating armor, drawing grids and managing toggles and variables.
|
|
- Equipment functions
|
|
- Reset equipment states
|
|
- Startup
|
|
* Scripts for artillery cannon fire selection tool
|
|
* Scripts for basic shortcuts
|
|
- Character lamp
|
|
- Emergency locator beacon
|
|
- Grid
|
|
- Rail block visualisation
|
|
- Zoom
|
|
* Script for shortcuts that give an item
|
|
* Scripts for vehicle shortcuts
|
|
- Functions
|
|
- on_player_driving_changed_state
|
|
- on_gui_closed
|
|
* on_lua_shortcut
|
|
- Basic
|
|
- Equipment
|
|
- Vehicle
|
|
- Give item
|
|
* Custom inputs
|
|
- Functions
|
|
- Basic
|
|
- Blueprint
|
|
- Equipment
|
|
- Vehicle
|
|
- Give item
|
|
]]
|
|
|
|
|
|
require("scripts.on-player-created")
|
|
require("scripts.on-research-finished")
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- STARTUP
|
|
---------------------------------------------------------------------------------------------------
|
|
local function initialize()
|
|
for name in pairs(game.forces) do
|
|
game.forces[name].reset_technology_effects()
|
|
end
|
|
if global.shortcuts_light == nil then
|
|
global.shortcuts_light = {}
|
|
end
|
|
if global.toggle_rail == nil then
|
|
global.toggle_rail = {}
|
|
end
|
|
if global.shortcuts_armor == nil then
|
|
global.shortcuts_armor = {}
|
|
end
|
|
if global.shortcuts_grid == nil then
|
|
global.shortcuts_grid = {}
|
|
end
|
|
if global.shortcuts_jetpack == nil then
|
|
global.shortcuts_jetpack = {}
|
|
end
|
|
end
|
|
|
|
script.on_init(initialize)
|
|
|
|
local function configuration_changed()
|
|
initialize()
|
|
for _, player in pairs(game.players) do
|
|
if settings.startup["ick-compatibility-mode"].value == false then
|
|
ick_reset_available_shortcuts(player)
|
|
end
|
|
end
|
|
end
|
|
|
|
script.on_configuration_changed(configuration_changed)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- EQUIPMENT FUNCTIONS
|
|
---------------------------------------------------------------------------------------------------
|
|
local function update_armor(player)
|
|
local power_armor = player.get_inventory(defines.inventory.character_armor)
|
|
if power_armor and power_armor.valid then
|
|
if power_armor[1].valid_for_read then
|
|
if power_armor[1].grid and power_armor[1].grid.valid and power_armor[1].grid.width > 0 then
|
|
global.shortcuts_armor[player.index] = power_armor[1].grid
|
|
else
|
|
table.remove(global.shortcuts_armor, player.index)
|
|
end
|
|
else
|
|
table.remove(global.shortcuts_armor, player.index)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function update_state(event, equipment_type) -- toggles the armor
|
|
local player = game.players[event.player_index]
|
|
if player.character then
|
|
update_armor(player)
|
|
local grid = global.shortcuts_armor[event.player_index]
|
|
if grid and grid.valid then
|
|
for _, equipment in pairs(grid.equipment) do
|
|
if equipment.valid and equipment.type == equipment_type then
|
|
local name = equipment.name
|
|
local position = equipment.position
|
|
local energy = equipment.energy
|
|
if not (string.sub(equipment.name, 1, 9) == "disabled-" or string.sub(equipment.name, 1, 4) == "nvt-") then
|
|
if equipment_type ~= "active-defense-equipment" or (equipment_type == "active-defense-equipment" and game.equipment_prototypes["disabled-" .. equipment.name]) then
|
|
grid.take{name = name, position = position}
|
|
local new_equipment = grid.put{name = "disabled-" .. name, position = position}
|
|
if new_equipment and new_equipment.valid then
|
|
new_equipment.energy = energy
|
|
end
|
|
player.set_shortcut_toggled(equipment_type, false)
|
|
end
|
|
elseif (string.sub(equipment.name, 1, 9) == "disabled-") then
|
|
grid.take{name = name, position = position}
|
|
local new_equipment = grid.put{name = (string.sub(name, 10, #name)), position = position}
|
|
if new_equipment and new_equipment.valid then
|
|
new_equipment.energy = energy
|
|
end
|
|
player.set_shortcut_toggled(equipment_type, true)
|
|
-- make it compatible with NightvisionToggles
|
|
elseif (string.sub(equipment.name, 1, 4) == "nvt-") then
|
|
grid.take{name = name, position = position}
|
|
local new_equipment = grid.put{name = (string.sub(name, 5, #name)), position = position}
|
|
if new_equipment and new_equipment.valid then
|
|
new_equipment.energy = energy
|
|
end
|
|
player.set_shortcut_toggled(equipment_type, true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function false_shortcuts(player) -- disables things
|
|
if settings.startup["night-vision-equipment"].value then
|
|
player.set_shortcut_available("night-vision-equipment", false)
|
|
player.set_shortcut_toggled("night-vision-equipment", false)
|
|
end
|
|
if settings.startup["active-defense-equipment"].value then
|
|
player.set_shortcut_available("active-defense-equipment", false)
|
|
player.set_shortcut_toggled("active-defense-equipment", false)
|
|
end
|
|
if settings.startup["belt-immunity-equipment"].value then
|
|
player.set_shortcut_available("belt-immunity-equipment", false)
|
|
player.set_shortcut_toggled("belt-immunity-equipment", false)
|
|
end
|
|
end
|
|
|
|
local function enable_it(player, equipment, grid, type) -- enables things
|
|
if grid.valid and equipment.valid then
|
|
local name = equipment.name
|
|
local position = equipment.position
|
|
local energy = equipment.energy
|
|
player.set_shortcut_available(type, true)
|
|
player.set_shortcut_toggled(type, true)
|
|
if (string.sub(equipment.name, 1, 9) == "disabled-") then
|
|
grid.take{name = name, position = position}
|
|
local new_equipment = grid.put{name = (string.sub(name, 10, #name)), position = position}
|
|
if new_equipment and new_equipment.valid then
|
|
new_equipment.energy = energy
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- RESET EQUIPMENT STATE
|
|
---------------------------------------------------------------------------------------------------
|
|
local function reset_state(event, toggle) -- verifies placement of equipment and armor switching
|
|
local player = game.players[event.player_index]
|
|
update_armor(player)
|
|
local grid = global.shortcuts_armor[event.player_index]
|
|
if grid and grid.valid then
|
|
if settings.startup["discharge-defense-remote"].value then
|
|
player.set_shortcut_available("discharge-defense-remote", false)
|
|
for _, equipment in pairs(grid.equipment) do
|
|
if equipment.name == "discharge-defense-equipment" then
|
|
player.set_shortcut_available("discharge-defense-remote", true)
|
|
end
|
|
end
|
|
end
|
|
local equipment = event.equipment
|
|
if equipment and toggle == 1 then --place
|
|
local type = equipment.type
|
|
if type == "night-vision-equipment" or type == "belt-immunity-equipment" or (type == "active-defense-equipment" and game.equipment_prototypes["disabledinactive-" .. equipment.name] == nil) then
|
|
if settings.startup[type] and settings.startup[type].value then
|
|
for _, equipment in pairs(grid.equipment) do -- Enable all of a type of equipment, even if only one is placed in the grid.
|
|
if equipment.valid and equipment.type == type then
|
|
enable_it(player, equipment, grid, type)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif equipment and toggle == 2 then --take
|
|
local type = game.equipment_prototypes[equipment].type
|
|
local name = game.equipment_prototypes[equipment].name
|
|
if type == "night-vision-equipment" or type == "belt-immunity-equipment" or type == "active-defense-equipment" then
|
|
if settings.startup[type] and settings.startup[type].value then
|
|
local value = false
|
|
for _, equipment in pairs(grid.equipment) do
|
|
if equipment.type == type and equipment.valid then
|
|
if game.equipment_prototypes["disabledinactive-" .. equipment.name] then else
|
|
value = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if value == false then
|
|
player.set_shortcut_available(type, false)
|
|
player.set_shortcut_toggled(type, false)
|
|
end
|
|
end
|
|
end
|
|
elseif toggle == 0 then --armor place
|
|
false_shortcuts(player)
|
|
for _, equipment in pairs(grid.equipment) do
|
|
local type = equipment.type
|
|
if equipment.valid and type == "night-vision-equipment" or type == "belt-immunity-equipment" or (type == "active-defense-equipment" and game.equipment_prototypes["disabledinactive-" .. equipment.name] == nil) then
|
|
if settings.startup[type] and settings.startup[type].value then
|
|
enable_it(player, equipment, grid, equipment.type)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
false_shortcuts(player)
|
|
if settings.startup["discharge-defense-remote"].value then
|
|
player.set_shortcut_available("discharge-defense-remote", false)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
remote.add_interface("Shortcuts-ick", { -- Checks if the armor inventory change was caused by the jetpack mod.
|
|
on_character_swapped = function(data)
|
|
if data.new_character.get_inventory(defines.inventory.character_armor).is_empty() == false and data.new_character.player then
|
|
global.shortcuts_jetpack[data.new_character.player.index] = true
|
|
end
|
|
end
|
|
})
|
|
|
|
|
|
script.on_event(defines.events.on_player_armor_inventory_changed, function(event)
|
|
if global.shortcuts_jetpack[event.player_index] == nil then
|
|
reset_state(event, 0) -- If no change by the jetpack mod was detected the equipment gets reset.
|
|
else
|
|
global.shortcuts_jetpack[event.player_index] = nil -- Otherwise clear the global again.
|
|
end
|
|
end)
|
|
script.on_event(defines.events.on_player_placed_equipment, function(event)
|
|
reset_state(event, 1)
|
|
end)
|
|
script.on_event(defines.events.on_player_removed_equipment, function(event)
|
|
reset_state(event, 2)
|
|
end)
|
|
-- Not using on_equipment_inserted and on_equipment_removed because the changes would trigger them again.
|
|
|
|
|
|
script.on_event(defines.events.on_player_toggled_map_editor, function(event) -- make equipment shortcuts unavailable while in editor
|
|
local player = game.players[event.player_index]
|
|
local toggle = true
|
|
if player.controller_type == defines.controllers.editor then
|
|
toggle = false
|
|
end
|
|
if settings.startup["night-vision-equipment"].value then
|
|
player.set_shortcut_available("night-vision-equipment", toggle)
|
|
end
|
|
if settings.startup["active-defense-equipment"].value then
|
|
player.set_shortcut_available("active-defense-equipment", toggle)
|
|
end
|
|
if settings.startup["belt-immunity-equipment"].value then
|
|
player.set_shortcut_available("belt-immunity-equipment", toggle)
|
|
end
|
|
if settings.startup["discharge-defense-remote"].value then
|
|
player.set_shortcut_available("discharge-defense-remote", toggle)
|
|
end
|
|
end)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- TOGGLE ARTILLERY CANNON FIRE SELECTION TOOL
|
|
---------------------------------------------------------------------------------------------------
|
|
local function artillery_swap(entity, new_name)
|
|
local shellname = {}
|
|
local shellcount = {}
|
|
local inventory = {}
|
|
local manual_mode = true
|
|
local speed = 0
|
|
local old_equipment = false
|
|
if entity.type == "artillery-wagon" and entity.name ~= "entity-ghost" then
|
|
inventory = entity.get_inventory(defines.inventory.artillery_wagon_ammo)
|
|
manual_mode = entity.train.manual_mode
|
|
speed = entity.train.speed
|
|
if entity.grid and entity.grid.equipment[1] then
|
|
old_equipment = {}
|
|
for _, equipment in pairs(entity.grid.equipment) do
|
|
table.insert(old_equipment, {name = equipment.name, position = equipment.position, energy = equipment.energy, shield = equipment.shield})
|
|
end
|
|
end
|
|
elseif entity.type == "artillery-turret" and entity.name ~= "entity-ghost" then
|
|
inventory = entity.get_inventory(defines.inventory.artillery_turret_ammo)
|
|
end
|
|
|
|
for i=1,(#inventory) do
|
|
if inventory[i].valid_for_read then
|
|
shellname[#shellname+1] = inventory[i].name
|
|
shellcount[#shellcount+1] = inventory[i].count
|
|
end
|
|
end
|
|
|
|
local surface = entity.surface.name
|
|
local position = entity.position
|
|
local direction = entity.direction
|
|
local orientation = entity.orientation
|
|
local force = entity.force
|
|
local kills = entity.kills
|
|
local damage = entity.damage_dealt
|
|
local health = entity.health
|
|
local new_entity = {}
|
|
|
|
if entity.name == "entity-ghost" then
|
|
local ghost = string.sub(entity.ghost_name,10)
|
|
if string.sub(entity.ghost_name,1,9) ~= "disabled-" then
|
|
ghost = "disabled-"..entity.ghost_name
|
|
end
|
|
entity.destroy()
|
|
new_entity = game.surfaces[surface].create_entity{
|
|
name = "entity-ghost",
|
|
ghost_name = ghost,
|
|
position = position,
|
|
direction = direction,
|
|
orientation = orientation,
|
|
force = force,
|
|
}
|
|
else
|
|
entity.destroy()
|
|
new_entity = game.surfaces[surface].create_entity{
|
|
name = new_name,
|
|
position = position,
|
|
direction = direction,
|
|
orientation = orientation,
|
|
force = force,
|
|
create_build_effect_smoke = false
|
|
}
|
|
end
|
|
if new_entity and new_entity.name ~= "entity-ghost" then
|
|
new_entity.kills = kills
|
|
new_entity.damage_dealt = damage
|
|
new_entity.health = health
|
|
for i, stack in pairs(shellcount) do
|
|
if new_entity.can_insert({name = shellname[i], count = shellcount[i]}) then
|
|
new_entity.insert({name = shellname[i], count = shellcount[i]})
|
|
end
|
|
end
|
|
if new_entity.type == "artillery-wagon" then
|
|
new_entity.train.speed = speed
|
|
new_entity.train.manual_mode = manual_mode
|
|
end
|
|
if old_equipment then
|
|
for _, old_equipment in pairs(old_equipment) do
|
|
local new_equipment = new_entity.grid.put{name = old_equipment.name, position = old_equipment.position}
|
|
new_equipment.energy = old_equipment.energy
|
|
if new_equipment.max_shield > 0 then
|
|
new_equipment.shield = old_equipment.shield
|
|
end
|
|
end
|
|
end
|
|
elseif new_entity.name ~= "entity-ghost" then
|
|
player.print({"", {"Shortcuts-ick.error-artillery"}, " (ERROR 1)"})
|
|
end
|
|
return new_entity
|
|
end
|
|
|
|
local artillery_setting = settings.startup["artillery-toggle"].value
|
|
if artillery_setting == "both" or artillery_setting == "artillery-turret" or artillery_setting == "artillery-wagon" then
|
|
|
|
local entity_type_filter = {}
|
|
|
|
if artillery_setting == "both" then
|
|
entity_type_filter = {{filter="type", type = "artillery-turret"}, {filter="type", type = "artillery-wagon"}}
|
|
else
|
|
entity_type_filter = {{filter="type", type = artillery_setting}}
|
|
end
|
|
|
|
local function draw_warning_icon(entity)
|
|
rendering.draw_sprite{
|
|
sprite = "utility.warning_icon",
|
|
x_scale = 1, y_scale = 1,
|
|
target_offset = {0.0,-0.25},
|
|
render_layer = "entity-info-icon-above",
|
|
target = entity,
|
|
surface = entity.surface,
|
|
forces = {entity.force}
|
|
}
|
|
end
|
|
|
|
script.on_event(defines.events.on_player_selected_area, function(event)
|
|
if event.item == "artillery-jammer-tool" and event.entities ~= nil then
|
|
local i = 0
|
|
local j = 0
|
|
for _, entity in pairs(event.entities) do
|
|
local name = entity.name
|
|
local type = entity.type
|
|
if entity.valid then
|
|
if string.sub(name,1,9) == "disabled-" or (name == "entity-ghost" and string.sub(entity.ghost_name, 1, 9) == "disabled-") then
|
|
j = j+1
|
|
artillery_swap(entity, string.sub(name, 10, #name))
|
|
else
|
|
local new_name = "disabled-" .. name
|
|
if game.entity_prototypes[new_name] or (name == "entity-ghost" and game.entity_prototypes["disabled-"..entity.ghost_name]) then
|
|
i = i+1
|
|
draw_warning_icon(artillery_swap(entity, new_name))
|
|
else
|
|
player.print({"", {"Shortcuts-ick.error-artillery"}, " (ERROR 2)"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if game.is_multiplayer() then
|
|
local player = game.players[event.player_index]
|
|
local message = ("Player " .. player.name .. " on surface " .. player.surface.name .. " has ")
|
|
if i ~= 0 and j == 0 then
|
|
player.force.print(message .. "disabled " .. i .. " artillery")
|
|
elseif i == 0 and j ~= 0 then
|
|
player.force.print(message .. "enabled " .. j .. " artillery")
|
|
elseif i ~= 0 and j ~= 0 then
|
|
player.force.print(message .. "enabled " .. j .. " and disabled " .. i .. " artillery")
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
--[[
|
|
script.on_event(defines.events.on_player_reverse_selected_area, function(event)
|
|
-- enable selected artillery
|
|
-- replace above
|
|
end)
|
|
|
|
script.on_event(defines.events.on_player_reverse_selected_area, function(event)
|
|
-- disable selected artillery
|
|
end)
|
|
|
|
script.on_event(defines.events.on_player_alt_selected_area, function(event)
|
|
-- enable not selected artillery on that surface
|
|
end)
|
|
|
|
script.on_event(defines.events.on_player_alt_reverse_selected_area, function(event)
|
|
-- disable not selected artillery on that surface
|
|
-- this event doen't exist
|
|
end)
|
|
]]
|
|
|
|
script.on_event(defines.events.on_robot_built_entity, function(event)
|
|
local entity = event.created_entity
|
|
if string.sub(entity.name, 1, 9) == "disabled-" then
|
|
draw_warning_icon(entity)
|
|
end
|
|
end, entity_type_filter)
|
|
|
|
script.on_event(defines.events.on_built_entity, function(event)
|
|
local entity = event.created_entity
|
|
if string.sub(entity.ghost_name, 1, 9) == "disabled-" then
|
|
draw_warning_icon(entity)
|
|
end
|
|
end, {{filter="ghost"}})
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- PREPARE UNINSTAL
|
|
---------------------------------------------------------------------------------------------------
|
|
script.on_event(defines.events.on_runtime_mod_setting_changed, function(event)
|
|
local mode = settings.global["ick-prepare-uninstall"].value
|
|
if event.setting_type == "runtime-global" and event.setting == "ick-prepare-uninstall" and mode ~= "" then
|
|
local function enable_artillery()
|
|
for surface_name in pairs(game.surfaces) do
|
|
local surface = game.surfaces[surface_name]
|
|
local artillery = surface.find_entities_filtered{type= {"artillery-turret", "artillery-wagon"}}
|
|
local artillery_ghosts = surface.find_entities_filtered{ghost_type= {"artillery-turret", "artillery-wagon"}}
|
|
local count = 0
|
|
for _, array in pairs({artillery, artillery_ghosts}) do
|
|
for _, entity in ipairs(array) do
|
|
if entity.valid then
|
|
local name = entity.name
|
|
if string.sub(name, 1, 9) == "disabled-" or (name == "entity-ghost" and string.sub(entity.ghost_name, 1, 9) == "disabled-") then
|
|
artillery_swap(entity, string.sub(name, 10, #name))
|
|
count = count + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if count > 0 then
|
|
game.print("SURFACE: " .. surface_name .. "\nNumber of artillery turrets and waggons (including ghosts) enabled: " .. count)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function enable_equipment(equipment_name)
|
|
for _, player in pairs(game.players) do
|
|
local armor = player.get_inventory(defines.inventory.character_armor)
|
|
if armor and armor.valid and armor[1].valid_for_read then
|
|
local grid = armor[1].grid
|
|
if grid and grid.valid and grid.get_contents() then
|
|
local count = 0
|
|
for _, equipment in pairs(grid.equipment) do
|
|
if equipment.name == "disabled-" .. equipment_name then
|
|
local position = equipment.position
|
|
grid.take{name = equipment.name, position = position}
|
|
local new_equipment = grid.put{name = equipment_name, position = position}
|
|
if global.shortcuts_armor[i] and global.shortcuts_armor[i].get(position) then
|
|
new_equipment.energy = global.shortcuts_armor[i].get(position).energy
|
|
global.shortcuts_armor[i] = grid
|
|
end
|
|
count = count + 1
|
|
end
|
|
end
|
|
if count > 0 then
|
|
game.print("PLAYER: " .. player.name .. "\nNumber of equipment pieces enabled: " .. count)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function enable_recipe(recipe, tech)
|
|
if game.recipe_prototypes[recipe] and game.technology_prototypes[tech] then
|
|
for _, force in pairs(game.forces) do
|
|
if force.technologies[tech].researched then
|
|
force.recipes[recipe].enabled = true
|
|
game.print("FORCE: " .. force.name .."\nEnabled Recipe: " .. game.recipe_prototypes[recipe].name)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if mode == "uninstall" then
|
|
enable_artillery()
|
|
for _, equipment_name in pairs({"active-defense-equipment", "belt-immunity-equipment", "night-vision-equipment"}) do
|
|
enable_equipment(equipment_name)
|
|
end
|
|
enable_recipe("artillery-targeting-remote", "artillery")
|
|
enable_recipe("discharge-defense-remote", "discharge-defense-equipment")
|
|
enable_recipe("spidertron-remote", "spidertron")
|
|
enable_recipe("artillery-cluster-remote-artillery-shell", "artillery")
|
|
enable_recipe("artillery-discovery-remote", "artillery")
|
|
enable_recipe("mirv-targeting-remote", "mirv-technology")
|
|
enable_recipe("atomic-artillery-targeting-remote", "atomic-artillery")
|
|
enable_recipe("landmine-thrower-remote", "landmine-thrower")
|
|
enable_recipe("winch", "vehicle-wagons")
|
|
enable_recipe("ion-cannon-targeter", "orbital-ion-cannon")
|
|
game.print("\nREADY TO UNINSTALL")
|
|
elseif mode == "artillery" then
|
|
enable_artillery()
|
|
game.print({"", "READY TO DISABLE SETTING: ", {"Shortcuts-ick.artillery-toggle"}})
|
|
elseif mode == "active-defense-equipment" or mode == "belt-immunity-equipment" or mode == "night-vision-equipment" then
|
|
enable_equipment(mode)
|
|
else
|
|
game.print("There went something wrong. Please make sure you entered the right word. (ERROR X)")
|
|
end
|
|
settings.global["ick-prepare-uninstall"] = {value = ""}
|
|
end
|
|
end)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- BASIC
|
|
---------------------------------------------------------------------------------------------------
|
|
-- CHARACTER LAMP
|
|
local function toggle_light(player)
|
|
if player.character then
|
|
if global.shortcuts_light[player.index] == nil then
|
|
global.shortcuts_light[player.index] = true
|
|
end
|
|
if global.shortcuts_light[player.index] then
|
|
player.character.disable_flashlight()
|
|
global.shortcuts_light[player.index] = false
|
|
player.set_shortcut_toggled("flashlight-toggle", false)
|
|
elseif global.shortcuts_light[player.index] == false then
|
|
player.character.enable_flashlight()
|
|
global.shortcuts_light[player.index] = true
|
|
player.set_shortcut_toggled("flashlight-toggle", true)
|
|
end
|
|
else
|
|
player.print({"", {"error.error-message-box-title"}, ": ", {"player-doesnt-exist", {"gui.character"}}, " (", {"controller.god"}, "): ", {"entity-name.small-lamp"}, " ", {"gui-mod-info.status-disabled"}})
|
|
end
|
|
end
|
|
|
|
-- EMERGENCY LOCATOR BEACON
|
|
local function signal_flare(player)
|
|
if settings.global["disable-flare"].value then
|
|
player.force.print({"", "[img=utility.danger_icon] [color=1,0.1,0.1]", {"entity-name.character"}, " " .. player.name .. " [gps=" .. math.floor(player.position.x+0.5) .. "," .. math.floor(player.position.y+0.5) .. "][/color] [img=utility.danger_icon]"})
|
|
else
|
|
player.print({"", {"error.error-message-box-title"}, ": ", {"technology-name.military"}, " ", {"entity-name.beacon"}, " ", {"gui-mod-info.status-disabled"}})
|
|
end
|
|
end
|
|
|
|
-- GRID
|
|
local function draw_grid(player_index)
|
|
local player = game.players[player_index]
|
|
if global.shortcuts_grid[player_index] == nil then
|
|
global.shortcuts_grid[player_index] = {}
|
|
end
|
|
-- game.print(#global.shortcuts_grid[player_index])
|
|
if #global.shortcuts_grid[player_index] == 0 then
|
|
player.set_shortcut_toggled("draw-grid", true)
|
|
-- Opts
|
|
local settings = settings.get_player_settings(player)
|
|
local radius = settings["grid-radius"].value
|
|
local chunk_size = settings["grid-chunk-size"].value
|
|
local step = settings["grid-step"].value
|
|
local thinn_width = settings["grid-line-width"].value
|
|
local thicc_width = settings["grid-chunk-line-width"].value
|
|
|
|
local ground_grid = false
|
|
if settings["grid-ground"].value == "ground" then
|
|
ground_grid = true
|
|
end
|
|
|
|
local center_x = math.floor(player.position.x)
|
|
local center_y = math.floor(player.position.y)
|
|
if settings["grid-chunk-align"].value == "chunk" then
|
|
center_x = math.floor(player.position.x/chunk_size)*chunk_size
|
|
center_y = math.floor(player.position.y/chunk_size)*chunk_size
|
|
end
|
|
for i = -radius, radius, step do
|
|
local width = thinn_width
|
|
if i % chunk_size == 0 then
|
|
width = thicc_width
|
|
end
|
|
if width > 0 then
|
|
local line = rendering.draw_line{
|
|
color = {r = 0, g = 0, b = 0, a = 1},
|
|
width = width,
|
|
from = {center_x+i,center_y+radius},
|
|
to = {center_x+i,center_y-radius},
|
|
surface = player.surface,
|
|
players = {player},
|
|
draw_on_ground = ground_grid
|
|
}
|
|
global.shortcuts_grid[player_index][#global.shortcuts_grid[player_index]+1] = line
|
|
end
|
|
|
|
local width = thinn_width
|
|
if i % chunk_size == 0 then
|
|
width = thicc_width
|
|
end
|
|
if width > 0 then
|
|
local line = rendering.draw_line{
|
|
color = {r = 0, g = 0, b = 0, a = 1},
|
|
width = width,
|
|
from = {center_x+radius,center_y+i},
|
|
to = {center_x-radius,center_y+i},
|
|
surface = player.surface,
|
|
players = {player},
|
|
draw_on_ground = ground_grid
|
|
}
|
|
global.shortcuts_grid[player_index][#global.shortcuts_grid[player_index]+1] = line
|
|
end
|
|
end
|
|
else
|
|
player.set_shortcut_toggled("draw-grid", false)
|
|
local grid = global.shortcuts_grid[player_index]
|
|
for i=1,(#grid) do
|
|
rendering.destroy(grid[i])
|
|
grid[i] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
-- RAIL BLOCK VISUALISATION
|
|
local function toggle_rail(player)
|
|
if global.toggle_rail[player.index] == nil then
|
|
global.toggle_rail[player.index] = false
|
|
end
|
|
if global.toggle_rail[player.index] then
|
|
player.game_view_settings.show_rail_block_visualisation = false
|
|
global.toggle_rail[player.index] = false
|
|
player.set_shortcut_toggled("rail-block-visualization-toggle", false)
|
|
elseif global.toggle_rail[player.index] == false then
|
|
player.game_view_settings.show_rail_block_visualisation = true
|
|
global.toggle_rail[player.index] = true
|
|
player.set_shortcut_toggled("rail-block-visualization-toggle", true)
|
|
end
|
|
end
|
|
|
|
-- BIG ZOOM
|
|
local function big_zoom(player)
|
|
if settings.global["disable-zoom"].value then
|
|
player.zoom = settings.get_player_settings(player)["zoom-level"].value
|
|
else
|
|
player.print({"", {"error.error-message-box-title"}, ": ", {"controls.alt-zoom-out"}, " ", {"gui-mod-info.status-disabled"}})
|
|
end
|
|
end
|
|
|
|
-- MINIMAP
|
|
local function toggle_minimap(player)
|
|
if player.minimap_enabled then
|
|
player.minimap_enabled = false
|
|
player.set_shortcut_toggled("minimap", false)
|
|
else
|
|
player.minimap_enabled = true
|
|
player.set_shortcut_toggled("minimap", true)
|
|
end
|
|
end
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- GIVE ITEM
|
|
---------------------------------------------------------------------------------------------------
|
|
local allowed_items = {
|
|
"artillery-cluster-remote-artillery-shell",
|
|
"artillery-discovery-remote",
|
|
"artillery-jammer-tool",
|
|
"artillery-targeting-remote",
|
|
"artillery-bombardment-remote",
|
|
"smart-artillery-bombardment-remote",
|
|
"smart-artillery-exploration-remote",
|
|
"atomic-artillery-targeting-remote",
|
|
"discharge-defense-remote",
|
|
"ion-cannon-targeter",
|
|
"landmine-thrower-remote",
|
|
"mirv-targeting-remote",
|
|
"path-remote-control",
|
|
"unit-remote-control",
|
|
"spidertron-remote",
|
|
"squad-spidertron-remote",
|
|
"tree-killer",
|
|
"well-planner",
|
|
"winch"}
|
|
|
|
local function remove_duplicate_tools(player, prototype_name)
|
|
for i=1, #player.get_main_inventory() do
|
|
if player.get_main_inventory()[i].valid_for_read and player.get_main_inventory()[i].name == prototype_name then
|
|
player.get_main_inventory()[i].clear()
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
local function tree_killer_setup(player)
|
|
local settings = settings.get_player_settings(player)
|
|
local entity_types = {}
|
|
if settings["environment-killer-item"].value then
|
|
table.insert(entity_types, "item-entity")
|
|
end
|
|
if settings["environment-killer-cliff"].value then
|
|
table.insert(entity_types, "cliff")
|
|
end
|
|
if settings["environment-killer-fish"].value then
|
|
table.insert(entity_types, "fish")
|
|
end
|
|
if settings["environment-killer-rocks"].value then
|
|
table.insert(entity_types, "simple-entity")
|
|
end
|
|
if settings["environment-killer-trees"].value then
|
|
table.insert(entity_types, "tree")
|
|
end
|
|
if #entity_types == 2 and (entity_types[1] == "tree" or entity_types[2] == "tree") and (entity_types[1] == "simple-entity" or entity_types[2] == "simple-entity") then
|
|
player.cursor_stack.trees_and_rocks_only = true
|
|
else
|
|
local filters = {}
|
|
for _, type in pairs(entity_types) do
|
|
for _, entity in pairs(game.get_filtered_entity_prototypes({{filter = "type", type = type}})) do
|
|
if entity.has_flag("not-deconstructable") == false and (type == "cliff" or entity.mineable_properties.minable) then
|
|
if #filters < 255 then
|
|
if type == "simple-entity" then
|
|
if game.entity_prototypes[entity.name].count_as_rock_for_filtered_deconstruction then
|
|
table.insert(filters, entity.name)
|
|
end
|
|
else
|
|
table.insert(filters, entity.name)
|
|
end
|
|
else
|
|
player.print({"", {"Shortcuts-ick.error-environment", type}, " (ERROR 3)"})
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
player.cursor_stack.entity_filters = filters
|
|
end
|
|
end
|
|
|
|
|
|
local function give_shortcut_item(player, prototype_name)
|
|
if game.item_prototypes[prototype_name] and player.clear_cursor() then
|
|
player.cursor_stack.set_stack({name = prototype_name})
|
|
if prototype_name == "well-planner" then
|
|
remove_duplicate_tools(player, "well-planner")
|
|
elseif prototype_name == "rail-signal-planner" then
|
|
remove_duplicate_tools(player, "rail-signal-planner")
|
|
elseif prototype_name == "spidertron-remote" then
|
|
if settings.startup["spidertron-remote"].value == "enabled" then
|
|
for i=1, #player.get_main_inventory() do
|
|
if player.get_main_inventory()[i].valid_for_read and player.get_main_inventory()[i].name == "spidertron-remote" and player.get_main_inventory()[i].connected_entity == nil then
|
|
player.get_main_inventory()[i].clear()
|
|
end
|
|
end
|
|
end
|
|
elseif prototype_name == "tree-killer" then
|
|
tree_killer_setup(player)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-- CLEAR DUPLICATE SPIDERTRON REMOTES
|
|
if settings.startup["spidertron-remote"].value == "enabled" then
|
|
script.on_event(defines.events.on_player_configured_spider_remote, function(event)
|
|
local player = game.players[event.player_index]
|
|
local inventory = player.get_main_inventory()
|
|
for i=1, #inventory do
|
|
if inventory[i].valid_for_read and inventory[i].name == "spidertron-remote" and (inventory[i].connected_entity == event.vehicle or inventory[i].connected_entity == nil) then
|
|
inventory[i].clear()
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- VEHICLE UPDATES
|
|
---------------------------------------------------------------------------------------------------
|
|
-- FUNCTIONS
|
|
local spidertron_setting = settings.startup["spidertron-remote"].value
|
|
|
|
local function update_shortcuts(driver, vehicle_setting, prototype_name)
|
|
if driver.is_player() then --If driver is a player without character
|
|
driver.set_shortcut_available(prototype_name, true)
|
|
driver.set_shortcut_toggled(prototype_name, vehicle_setting)
|
|
elseif driver.player then --If driver is a character with player
|
|
driver.player.set_shortcut_available(prototype_name, true)
|
|
driver.player.set_shortcut_toggled(prototype_name, vehicle_setting)
|
|
end
|
|
end
|
|
|
|
local function vehicle_shortcuts(player, name, vehicle_types, parameter)
|
|
if player.driving then
|
|
local continue = false
|
|
for _, type in pairs(vehicle_types) do
|
|
if player.vehicle.type == type then
|
|
continue = true
|
|
break
|
|
end
|
|
end
|
|
if continue then
|
|
local vehicle = player.vehicle
|
|
if parameter == "auto_target_with_gunner" then
|
|
local params = player.vehicle.vehicle_automatic_targeting_parameters
|
|
if player.vehicle.vehicle_automatic_targeting_parameters.auto_target_with_gunner then
|
|
params.auto_target_with_gunner = false
|
|
player.vehicle.vehicle_automatic_targeting_parameters = params
|
|
else
|
|
params.auto_target_with_gunner = true
|
|
player.vehicle.vehicle_automatic_targeting_parameters = params
|
|
end
|
|
vehicle = player.vehicle.vehicle_automatic_targeting_parameters
|
|
else
|
|
if parameter == "manual_mode" then
|
|
vehicle = player.vehicle.train
|
|
end
|
|
if vehicle[parameter] then
|
|
vehicle[parameter] = false
|
|
else
|
|
vehicle[parameter] = true
|
|
end
|
|
end
|
|
if parameter == "manual_mode" then
|
|
for _, driver in pairs(vehicle.passengers) do
|
|
update_shortcuts(driver, vehicle[parameter], name)
|
|
end
|
|
else
|
|
for _, driver in pairs({player.vehicle.get_driver(), player.vehicle.get_passenger()}) do
|
|
update_shortcuts(driver, vehicle[parameter], name)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-- ON_PLAYER_DRIVING_CHANGED_STATE
|
|
script.on_event(defines.events.on_player_driving_changed_state, function(event)
|
|
local player = game.players[event.player_index]
|
|
local mods = game.active_mods
|
|
local setting = settings.startup
|
|
|
|
if player.driving then
|
|
local type = player.vehicle.type
|
|
local function enable_shortcuts(player, parameter, name)
|
|
if setting[name].value then
|
|
update_shortcuts(player, parameter, name)
|
|
end
|
|
end
|
|
if type == "car" or type == "spider-vehicle" then
|
|
enable_shortcuts(player, player.vehicle.driver_is_gunner, "driver-is-gunner")
|
|
end
|
|
if type == "spider-vehicle" then
|
|
if spidertron_setting == "enabled" or spidertron_setting == "enabled-hidden" then
|
|
player.set_shortcut_available("spidertron-remote", true)
|
|
end
|
|
if mods["Spider_Control"] then
|
|
player.set_shortcut_available("squad-spidertron-follow", true)
|
|
player.set_shortcut_available("squad-spidertron-remote", true)
|
|
player.set_shortcut_available("squad-spidertron-list", true)
|
|
player.set_shortcut_available("squad-spidertron-link-tool", true)
|
|
end
|
|
if mods["SpidertronWaypoints"] then
|
|
player.set_shortcut_available("spidertron-remote-waypoint", true)
|
|
player.set_shortcut_available("spidertron-remote-patrol", true)
|
|
end
|
|
enable_shortcuts(player, player.vehicle.enable_logistics_while_moving, "spidertron-logistics")
|
|
enable_shortcuts(player, player.vehicle.vehicle_logistic_requests_enabled, "spidertron-logistic-requests")
|
|
enable_shortcuts(player, player.vehicle.vehicle_automatic_targeting_parameters.auto_target_with_gunner, "targeting-with-gunner")
|
|
enable_shortcuts(player, player.vehicle.vehicle_automatic_targeting_parameters.auto_target_with_gunner, "targeting-without-gunner")
|
|
end
|
|
if type == "locomotive" or type == "cargo-wagon" or type == "fluid-wagon" or type == "artillery-wagon" then
|
|
enable_shortcuts(player, player.vehicle.train.manual_mode, "train-mode-toggle")
|
|
end
|
|
elseif player.driving == false then
|
|
local function disable_shortcuts(name)
|
|
if setting[name].value then
|
|
player.set_shortcut_available(name, false)
|
|
end
|
|
end
|
|
disable_shortcuts("driver-is-gunner")
|
|
disable_shortcuts("spidertron-logistics")
|
|
disable_shortcuts("spidertron-logistic-requests")
|
|
disable_shortcuts("targeting-with-gunner")
|
|
disable_shortcuts("targeting-without-gunner")
|
|
disable_shortcuts("train-mode-toggle")
|
|
end
|
|
end)
|
|
|
|
|
|
-- ON_GUI_CLOSED
|
|
script.on_event(defines.events.on_gui_closed, function(event)
|
|
if event.gui_type == 1 then
|
|
local entity = event.entity
|
|
local type = entity.type
|
|
local setting = settings.startup
|
|
local function search_vehicle(name, parameter)
|
|
if setting[name].value then
|
|
for _, driver in pairs({entity.get_driver(), entity.get_passenger()}) do
|
|
update_shortcuts(driver, parameter, name)
|
|
end
|
|
end
|
|
end
|
|
if type == "car" or type == "spider-vehicle" then
|
|
search_vehicle("driver-is-gunner", entity.driver_is_gunner)
|
|
end
|
|
if type == "spider-vehicle" then
|
|
search_vehicle("spidertron-logistics", entity.enable_logistics_while_moving)
|
|
search_vehicle("spidertron-logistic-requests", entity.vehicle_logistic_requests_enabled)
|
|
search_vehicle("targeting-with-gunner", entity.vehicle_automatic_targeting_parameters.auto_target_with_gunner)
|
|
search_vehicle("targeting-without-gunner", entity.vehicle_automatic_targeting_parameters.auto_target_without_gunner)
|
|
end
|
|
if setting["train-mode-toggle"].value and type == "locomotive" and entity.train.passengers then
|
|
for _, driver in pairs(entity.train.passengers) do
|
|
update_shortcuts(driver, entity.train.manual_mode, "train-mode-toggle")
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- ON LUA SHORTCUT
|
|
---------------------------------------------------------------------------------------------------
|
|
script.on_event(defines.events.on_lua_shortcut, function(event)
|
|
local prototype_name = event.prototype_name
|
|
local player = game.players[event.player_index]
|
|
|
|
-- BASIC
|
|
if prototype_name == "flashlight-toggle" then
|
|
toggle_light(player)
|
|
elseif prototype_name == "signal-flare" then
|
|
signal_flare(player)
|
|
elseif prototype_name == "draw-grid" then
|
|
draw_grid(event.player_index)
|
|
elseif prototype_name == "rail-block-visualization-toggle" then
|
|
toggle_rail(player)
|
|
elseif prototype_name == "big-zoom" then
|
|
big_zoom(player)
|
|
elseif prototype_name == "minimap" then
|
|
toggle_minimap(player)
|
|
|
|
-- EQUIPMENT
|
|
elseif prototype_name == "night-vision-equipment" then
|
|
update_state(event, "night-vision-equipment")
|
|
return
|
|
elseif prototype_name == "belt-immunity-equipment" then
|
|
update_state(event, "belt-immunity-equipment")
|
|
return
|
|
elseif prototype_name == "active-defense-equipment" then
|
|
update_state(event, "active-defense-equipment")
|
|
return
|
|
-- elseif prototype_name == "jetpack" then
|
|
|
|
-- VEHICLE
|
|
elseif prototype_name == "driver-is-gunner" then
|
|
vehicle_shortcuts(player, "driver-is-gunner", {"car", "spider-vehicle"}, "driver_is_gunner")
|
|
elseif prototype_name == "spidertron-logistics" then
|
|
vehicle_shortcuts(player, "spidertron-logistics", {"spider-vehicle"}, "enable_logistics_while_moving")
|
|
elseif prototype_name == "spidertron-logistic-requests" then
|
|
vehicle_shortcuts(player, "spidertron-logistic-requests", {"spider-vehicle"}, "vehicle_logistic_requests_enabled")
|
|
elseif prototype_name == "targeting-with-gunner" then
|
|
vehicle_shortcuts(player, "targeting-with-gunner", {"spider-vehicle"}, "auto_target_with_gunner")
|
|
elseif prototype_name == "targeting-without-gunner" then
|
|
vehicle_shortcuts(player, "targeting-without-gunner", {"spider-vehicle"}, "auto_target_without_gunner")
|
|
elseif prototype_name == "train-mode-toggle" then
|
|
vehicle_shortcuts(player, "train-mode-toggle", {"locomotive", "cargo-wagon", "fluid-wagon", "artillery-wagon"}, "manual_mode")
|
|
|
|
-- GIVE ITEM
|
|
elseif prototype_name == "check-circuit" then
|
|
give_shortcut_item(player, "circuit-checker")
|
|
elseif prototype_name == "pump-shortcut" then
|
|
give_shortcut_item(player, "pump-selection-tool")
|
|
elseif prototype_name == "give-rail-signal-planner" then
|
|
give_shortcut_item(player, "rail-signal-planner")
|
|
elseif game.shortcut_prototypes[prototype_name] then
|
|
for _, item_name in pairs(allowed_items) do
|
|
if item_name == prototype_name then
|
|
give_shortcut_item(player, prototype_name)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
|
|
---------------------------------------------------------------------------------------------------
|
|
-- CUSTOM INPUTS
|
|
---------------------------------------------------------------------------------------------------
|
|
-- FUNCTIONS
|
|
local function custom_input_equipment(name)
|
|
if settings.startup[name].value then
|
|
script.on_event(name, function(event)
|
|
update_state(event, name)
|
|
return
|
|
end)
|
|
end
|
|
end
|
|
|
|
local function custom_input_vehicle(name, vehicle_types, parameter)
|
|
if settings.startup[name].value then
|
|
script.on_event(name, function(event)
|
|
vehicle_shortcuts(game.players[event.player_index], name, vehicle_types, parameter)
|
|
end)
|
|
end
|
|
end
|
|
|
|
local function custom_input_give_item_2(item)
|
|
script.on_event(item, function(event)
|
|
local player = game.players[event.player_index]
|
|
if player.is_shortcut_available(item) then
|
|
give_shortcut_item(player, item)
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function custom_input_give_item_1(item)
|
|
if settings.startup[item] and settings.startup[item].value then
|
|
custom_input_give_item_2(item)
|
|
end
|
|
end
|
|
|
|
|
|
-- BASIC
|
|
if settings.startup["flashlight-toggle"].value then
|
|
script.on_event("flashlight-toggle", function(event)
|
|
toggle_light(game.players[event.player_index])
|
|
end)
|
|
end
|
|
if settings.startup["signal-flare"].value then
|
|
script.on_event("signal-flare", function(event)
|
|
signal_flare(game.players[event.player_index])
|
|
end)
|
|
end
|
|
if settings.startup["draw-grid"].value then
|
|
script.on_event("draw-grid", function(event)
|
|
draw_grid(event.player_index)
|
|
end)
|
|
end
|
|
if settings.startup["rail-block-visualization-toggle"].value then
|
|
script.on_event("rail-block-visualization-toggle", function(event)
|
|
local player = game.players[event.player_index]
|
|
if player.is_shortcut_available("rail-block-visualization-toggle") then
|
|
toggle_rail(player)
|
|
end
|
|
end)
|
|
end
|
|
if settings.startup["big-zoom"].value then
|
|
script.on_event("big-zoom", function(event)
|
|
big_zoom(game.players[event.player_index])
|
|
end)
|
|
end
|
|
if settings.startup["minimap"].value then
|
|
script.on_event("minimap", function(event)
|
|
toggle_minimap(game.players[event.player_index])
|
|
end)
|
|
end
|
|
|
|
|
|
-- EQUIPMENT
|
|
custom_input_equipment("belt-immunity-equipment")
|
|
custom_input_equipment("night-vision-equipment")
|
|
custom_input_equipment("active-defense-equipment")
|
|
|
|
|
|
-- VEHICLE
|
|
custom_input_vehicle("driver-is-gunner", {"car", "spider-vehicle"}, "driver_is_gunner")
|
|
custom_input_vehicle("spidertron-logistics", {"spider-vehicle"}, "enable_logistics_while_moving")
|
|
custom_input_vehicle("spidertron-logistic-requests", {"spider-vehicle"}, "vehicle_logistic_requests_enabled")
|
|
custom_input_vehicle("targeting-with-gunner", {"spider-vehicle"}, "auto_target_with_gunner")
|
|
custom_input_vehicle("targeting-without-gunner", {"spider-vehicle"}, "auto_target_without_gunner")
|
|
custom_input_vehicle("train-mode-toggle", {"locomotive", "cargo-wagon", "fluid-wagon", "artillery-wagon"}, "manual_mode")
|
|
|
|
|
|
-- GIVE ITEM
|
|
custom_input_give_item_1("tree-killer")
|
|
|
|
if settings.startup["artillery-targeting-remote"].value then
|
|
if settings.startup["advanced-artillery-remote"] and settings.startup["advanced-artillery-remote"].value then
|
|
custom_input_give_item_2("artillery-cluster-remote-artillery-shell")
|
|
custom_input_give_item_2("artillery-discovery-remote")
|
|
end
|
|
if settings.startup["artillery-bombardment-remote"] and settings.startup["artillery-bombardment-remote"].value then
|
|
custom_input_give_item_2("artillery-bombardment-remote")
|
|
custom_input_give_item_2("smart-artillery-bombardment-remote")
|
|
custom_input_give_item_2("smart-artillery-exploration-remote")
|
|
end
|
|
end
|
|
|
|
if artillery_setting == "both" or artillery_setting == "artillery-wagon" or artillery_setting == "artillery-turret" then
|
|
custom_input_give_item_2("artillery-jammer-tool")
|
|
end
|
|
|
|
custom_input_give_item_1("artillery-targeting-remote")
|
|
custom_input_give_item_1("atomic-artillery-targeting-remote")
|
|
custom_input_give_item_1("discharge-defense-remote")
|
|
custom_input_give_item_1("ion-cannon-targeter")
|
|
custom_input_give_item_1("landmine-thrower-remote")
|
|
custom_input_give_item_1("mirv-targeting-remote")
|
|
|
|
custom_input_give_item_1("well-planner")
|
|
custom_input_give_item_1("winch")
|
|
|
|
if spidertron_setting == "enabled" or spidertron_setting == "enabled-hidden" then
|
|
custom_input_give_item_2("spidertron-remote")
|
|
end
|