mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-10 00:43:27 +02:00
e21483149d
- Damage reduction for players work even with "lethal blows" (except when player is about to be one shotted and regenerates slight amount of health to still get oneshotted, but that's quite rare against biters, although if damage reduction works against uranium grenades, this last_health maybe should be updated every now and then (perhaps every 30 or 60 seconds)) - Moved a lot of class related hard coded constants to Balance.lua - New command: /classinfofull <class> - Samurai and Hatamoto classes melee damage now also scales from 'physical projectile damage' research bonus - Other various code related changes
1061 lines
29 KiB
Lua
1061 lines
29 KiB
Lua
-- This file is part of thesixthroc's Pirate Ship softmod, licensed under GPLv3 and stored at https://github.com/danielmartin0/ComfyFactorio-Pirates.
|
|
|
|
--luacheck: ignore
|
|
--luacheck ignores because mass requires is a code templating choice...
|
|
|
|
local Color = require 'utils.color_presets'
|
|
local Server = require 'utils.server'
|
|
|
|
local Math = require 'maps.pirates.math'
|
|
local Ai = require 'maps.pirates.ai'
|
|
local Memory = require 'maps.pirates.memory'
|
|
local Gui = require 'maps.pirates.gui.gui'
|
|
local Common = require 'maps.pirates.common'
|
|
local CoreData = require 'maps.pirates.coredata'
|
|
local PlayerColors = require 'maps.pirates.player_colors'
|
|
local Utils = require 'maps.pirates.utils_local'
|
|
|
|
local Balance = require 'maps.pirates.balance'
|
|
local Crew = require 'maps.pirates.crew'
|
|
local Roles = require 'maps.pirates.roles.roles'
|
|
local Structures = require 'maps.pirates.structures.structures'
|
|
local Boats = require 'maps.pirates.structures.boats.boats'
|
|
local Surfaces = require 'maps.pirates.surfaces.surfaces'
|
|
local Overworld = require 'maps.pirates.overworld'
|
|
local Islands = require 'maps.pirates.surfaces.islands.islands'
|
|
local Progression = require 'maps.pirates.progression'
|
|
local Crowsnest = require 'maps.pirates.surfaces.crowsnest'
|
|
local Hold = require 'maps.pirates.surfaces.hold'
|
|
local PiratesApiEvents = require 'maps.pirates.api_events'
|
|
local Upgrades = require 'maps.pirates.boat_upgrades'
|
|
local Effects = require 'maps.pirates.effects'
|
|
local Kraken = require 'maps.pirates.surfaces.sea.kraken'
|
|
local _inspect = require 'utils.inspect'.inspect
|
|
local simplex_noise = require 'utils.simplex_noise'.d2
|
|
local Token = require 'utils.token'
|
|
local Task = require 'utils.task'
|
|
local Highscore = require 'maps.pirates.highscore'
|
|
local CustomEvents = require 'maps.pirates.custom_events'
|
|
local Classes = require 'maps.pirates.roles.classes'
|
|
|
|
local GUIcolor = require 'maps.pirates.gui.color'
|
|
|
|
|
|
|
|
local function cmd_set_memory(cmd)
|
|
local crew_id = tonumber(string.sub(game.players[cmd.player_index].force.name, -3, -1)) or nil
|
|
Memory.set_working_id(crew_id)
|
|
end
|
|
|
|
|
|
local function check_admin(cmd)
|
|
local Session = require 'utils.datastore.session_data'
|
|
local player = game.players[cmd.player_index]
|
|
local trusted = Session.get_trusted_table()
|
|
local p
|
|
if player then
|
|
if player ~= nil then
|
|
p = player.print
|
|
if not player.admin then
|
|
p('[ERROR] Only admins are allowed to run this command!', Color.fail)
|
|
return false
|
|
end
|
|
else
|
|
p = log
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function check_captain(cmd)
|
|
local player = game.players[cmd.player_index]
|
|
local p
|
|
if player then
|
|
if player ~= nil then
|
|
p = player.print
|
|
if not Common.validate_player(player) then return end
|
|
if not (Roles.player_privilege_level(player) >= Roles.privilege_levels.CAPTAIN) then
|
|
p('[ERROR] Only captains are allowed to run this command!', Color.fail)
|
|
return false
|
|
end
|
|
else
|
|
p = log
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function check_captain_or_admin(cmd)
|
|
local player = game.players[cmd.player_index]
|
|
local p
|
|
if player then
|
|
if player ~= nil then
|
|
p = player.print
|
|
if not Common.validate_player(player) then return end
|
|
if not (player.admin or Roles.player_privilege_level(player) >= Roles.privilege_levels.CAPTAIN) then
|
|
p('[ERROR] Only captains are allowed to run this command!', Color.fail)
|
|
return false
|
|
end
|
|
else
|
|
p = log
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
local function check_trusted(cmd)
|
|
local Session = require 'utils.datastore.session_data'
|
|
local player = game.players[cmd.player_index]
|
|
local trusted = Session.get_trusted_table()
|
|
local p
|
|
if player then
|
|
if player ~= nil then
|
|
p = player.print
|
|
if not (trusted[player.name] or player.admin) then
|
|
p('[ERROR] Only admins and trusted weebs are allowed to run this command!', Color.fail)
|
|
return false
|
|
end
|
|
else
|
|
p = log
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
commands.add_command(
|
|
'set_max_crews',
|
|
'is an admin command to set the maximum number of concurrent crews allowed on the server.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local global_memory = Memory.get_global_memory()
|
|
|
|
if tonumber(param) then
|
|
global_memory.active_crews_cap = tonumber(param)
|
|
Common.notify_player_expected(player, 'The maximum number of concurrent crews has been set to ' .. param .. '.')
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'sail',
|
|
'is an admin command to set the ship sailing after an island, in case there\'s a problem with the captain doing so.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
Crew.summon_crew()
|
|
if memory.boat.state == Boats.enum_state.ATSEA_WAITING_TO_SAIL then
|
|
Progression.at_sea_begin_to_set_sail()
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'setcaptain',
|
|
'{player} is an admin command to set the crew\'s captain to {player}.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
if param and game.players[param] and game.players[param].index then
|
|
Roles.make_captain(game.players[param])
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Invalid player name.')
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'summoncrew',
|
|
'is an admin command to summon the crew to the ship.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local crew_id = tonumber(string.sub(player.force.name, -3, -1)) or nil
|
|
Memory.set_working_id(crew_id)
|
|
Crew.summon_crew()
|
|
end
|
|
end)
|
|
|
|
|
|
|
|
|
|
|
|
commands.add_command(
|
|
'ok',
|
|
'is used to accept captainhood.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
|
|
local memory = Memory.get_crew_memory()
|
|
Roles.player_confirm_captainhood(player)
|
|
end)
|
|
|
|
-- Disabled for information-flow reasons:
|
|
-- commands.add_command(
|
|
-- 'classes',
|
|
-- 'Prints the available classes in the game.',
|
|
-- function(cmd)
|
|
-- local player = game.players[cmd.player_index]
|
|
-- if not Common.validate_player(player) then return end
|
|
-- player.print('[color=gray]' .. Roles.get_classes_print_string() .. '[/color]')
|
|
-- end)
|
|
|
|
commands.add_command(
|
|
'classinfo',
|
|
'{classname} returns the definition of the named class.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
|
|
if param and param ~= 'nil' then
|
|
local string = Roles.get_class_print_string(param, false)
|
|
if string then
|
|
Common.notify_player_expected(player, {'', 'Class definition for ', string})
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Class ' .. param .. ' not found.')
|
|
end
|
|
else
|
|
Common.notify_player_expected(player, '/classinfo {classname} returns the definition of the named class.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'classinfofull',
|
|
'{classname} returns detailed definition of the named class.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
|
|
if param and param ~= 'nil' then
|
|
local string = Roles.get_class_print_string(param, true)
|
|
if string then
|
|
Common.notify_player_expected(player, {'', 'Class definition for ', string})
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Class ' .. param .. ' not found.')
|
|
end
|
|
else
|
|
Common.notify_player_expected(player, '/classinfofull {classname} returns detailed definition of the named class.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'take',
|
|
'{classname} takes a spare class with the given name for yourself.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
|
|
if param and param ~= 'nil' then
|
|
for _, class in pairs(Classes.enum) do
|
|
if Classes.eng_form[class]:lower() == param:lower() then
|
|
Classes.assign_class(player.index, class, true)
|
|
return true
|
|
end
|
|
end
|
|
--fallthrough:
|
|
Common.notify_player_error(player, 'Command error: Class ' .. param .. ' not found.')
|
|
return false
|
|
else
|
|
Common.notify_player_expected(player, '/take {classname} takes a spare class with the given name for yourself.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'giveup',
|
|
'gives up your current class, making it available for others.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
|
|
if param and param == 'nil' then
|
|
Classes.try_renounce_class(player, true)
|
|
else
|
|
Common.notify_player_error(player, 'Command error: parameter not needed.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ccolor',
|
|
'is an extension to the built-in /color command, with more colors.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
local player_index = cmd.player_index
|
|
if player_index then
|
|
local player = game.players[player_index]
|
|
if player and player.valid then
|
|
if cmd.parameter then
|
|
if PlayerColors.colors[param] then
|
|
local rgb = PlayerColors.colors[param]
|
|
player.color = rgb
|
|
player.chat_color = rgb
|
|
local message = {'', '[color=' .. rgb.r .. ',' .. rgb.g .. ',' .. rgb.b .. ']',{'pirates.choose_chat_color', player.name, param}, '[/color] (via /ccolor).'}
|
|
-- local message = '[color=' .. rgb.r .. ',' .. rgb.g .. ',' .. rgb.b .. ']' .. player.name .. ' chose the color ' .. param .. '[/color] (via /ccolor).'
|
|
Common.notify_game(message)
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Color \'' .. param .. '\' not found.')
|
|
end
|
|
else
|
|
local color = PlayerColors.bright_color_names[Math.random(#PlayerColors.bright_color_names)]
|
|
local rgb = PlayerColors.colors[color]
|
|
if not rgb then return end
|
|
player.color = rgb
|
|
player.chat_color = rgb
|
|
local message = {'', '[color=' .. rgb.r .. ',' .. rgb.g .. ',' .. rgb.b .. ']', {'pirates.randomize_chat_color', player.name, color}, '[/color] (via /ccolor).'} --'randomly became' was amusing, but let's not
|
|
-- local message = '[color=' .. rgb.r .. ',' .. rgb.g .. ',' .. rgb.b .. ']' .. player.name .. '\'s color randomized to ' .. color .. '[/color] (via /ccolor).' --'randomly became' was amusing, but let's not
|
|
Common.notify_game(message)
|
|
-- disabled due to lag:
|
|
-- GUIcolor.toggle_window(player)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
|
|
|
|
|
|
local go_2 = Token.register(
|
|
function(data)
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
|
|
memory.mapbeingloadeddestination_index = 1
|
|
memory.loadingticks = 0
|
|
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
-- surface.request_to_generate_chunks({x = 0, y = 0}, 10)
|
|
-- surface.force_generate_chunk_requests()
|
|
Progression.go_from_starting_dock_to_first_destination()
|
|
end
|
|
)
|
|
local go_1 = Token.register(
|
|
function(data)
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Overworld.ensure_lane_generated_up_to(0, Crowsnest.Data.visibilitywidth/2)
|
|
Overworld.ensure_lane_generated_up_to(24, Crowsnest.Data.visibilitywidth/2)
|
|
Overworld.ensure_lane_generated_up_to(-24, Crowsnest.Data.visibilitywidth/2)
|
|
memory.currentdestination_index = 1
|
|
script.raise_event(CustomEvents.enum['update_crew_progress_gui'], {})
|
|
Surfaces.create_surface(Common.current_destination())
|
|
Task.set_timeout_in_ticks(60, go_2, {})
|
|
end
|
|
)
|
|
|
|
|
|
|
|
commands.add_command(
|
|
'plank',
|
|
'is a captain command to remove a player by making them a spectator.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local player = game.players[cmd.player_index]
|
|
local param = tostring(cmd.parameter)
|
|
if check_captain_or_admin(cmd) then
|
|
if param and game.players[param] and game.players[param].index then
|
|
Crew.plank(player, game.players[param])
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Invalid player name.')
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'officer',
|
|
'is a captain command to make a player into an officer, or remove them as one.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local player = game.players[cmd.player_index]
|
|
local param = tostring(cmd.parameter)
|
|
if check_captain_or_admin(cmd) then
|
|
local memory = Memory.get_crew_memory()
|
|
if param and game.players[param] and game.players[param].index then
|
|
if memory.officers_table and memory.officers_table[game.players[param].index] then
|
|
Roles.unmake_officer(player, game.players[param])
|
|
else
|
|
Roles.make_officer(player, game.players[param])
|
|
end
|
|
else
|
|
Common.notify_player_error(player, 'Command error: Invalid player name.')
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'undock',
|
|
'is a captain command to undock the ship.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_captain_or_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
if memory.boat.state == Boats.enum_state.DOCKED then
|
|
Progression.undock_from_dock(true)
|
|
elseif memory.boat.state == Boats.enum_state.LANDED then
|
|
Progression.try_retreat_from_island(player, true)
|
|
end
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'tax',
|
|
'is a captain command to take a quarter of all coins, plus other game-critical items from the crew, into your inventory.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_captain(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
Roles.captain_tax(memory.playerindex_captain)
|
|
end --@TODO: else
|
|
end)
|
|
|
|
commands.add_command(
|
|
'dump_highscores',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
Highscore.dump_highscores()
|
|
player.print('Highscores dumped.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'setclass',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
if not Common.validate_player(player) then return end
|
|
if not memory.classes_table then memory.classes_table = {} end
|
|
memory.classes_table[player.index] = param
|
|
player.print('Set own class to ' .. param .. '.')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'setevo',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Common.set_evo(tonumber(param))
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'modi',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
local entities = surface.find_entities_filtered{position = player.position, radius = 500}
|
|
for _, e in pairs(entities) do
|
|
if e and e.valid then
|
|
-- e.force = memory.force
|
|
e.minable = true
|
|
e.destructible = true
|
|
e.rotatable = true
|
|
end
|
|
end
|
|
player.print('nearby entities made modifiable')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ret',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Progression.retreat_from_island(true)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'jump',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Overworld.try_overworld_move_v2({x = 40, y = 0})
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'advu',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Overworld.try_overworld_move_v2{x = 0, y = -24}
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'advd',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Overworld.try_overworld_move_v2{x = 0, y = 24}
|
|
end
|
|
end)
|
|
|
|
|
|
commands.add_command(
|
|
'overwrite_scores_specific',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
if not Common.validate_player(player) then return end
|
|
local memory = Memory.get_crew_memory()
|
|
if Highscore.overwrite_scores_specific() then player.print('Highscores overwritten.') end
|
|
end
|
|
end)
|
|
|
|
|
|
if _DEBUG then
|
|
|
|
commands.add_command(
|
|
'go',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
|
|
local proposal = {
|
|
capacity_option = 3,
|
|
difficulty_option = 2,
|
|
-- mode_option = 'left',
|
|
endorserindices = { 1 },
|
|
name = "AdminRun"
|
|
}
|
|
|
|
Memory.set_working_id(1)
|
|
|
|
Crew.initialise_crew(proposal)
|
|
Crew.initialise_crowsnest() --contains a Task
|
|
|
|
local memory = Memory.get_crew_memory()
|
|
local boat = Utils.deepcopy(Surfaces.Lobby.StartingBoats[memory.id])
|
|
|
|
for _, p in pairs(game.connected_players) do
|
|
p.teleport({x = -30, y = boat.position.y}, game.surfaces[boat.surface_name])
|
|
end
|
|
|
|
Progression.set_off_from_starting_dock()
|
|
|
|
-- local memory = Memory.get_crew_memory()
|
|
-- local boat = Utils.deepcopy(Surfaces.Lobby.StartingBoats[memory.id])
|
|
-- memory.boat = boat
|
|
-- boat.dockedposition = boat.position
|
|
-- boat.decksteeringchests = {}
|
|
-- boat.crowsneststeeringchests = {}
|
|
|
|
Task.set_timeout_in_ticks(120, go_1, {})
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'chnk',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
|
|
for i = 0, 13 do
|
|
for j = 0, 13 do
|
|
PiratesApiEvents.event_on_chunk_generated({surface = player.surface, area = {left_top = {x = -7 * 32 + i * 32, y = -7 * 32 + j * 32}}})
|
|
end
|
|
end
|
|
game.print('chunks generated')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'spd',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
memory.boat.speed = 60
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'stp',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
memory.boat.speed = 0
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'rms',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local rms = 0
|
|
local n = 100000
|
|
local seed = Math.random(n^2)
|
|
for i = 1,n do
|
|
local noise = simplex_noise(i, 7.11, seed)
|
|
rms = rms + noise^2
|
|
end
|
|
rms = rms/n
|
|
game.print(rms)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'pro',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local global_memory = Memory.get_global_memory()
|
|
|
|
local proposal = {
|
|
capacity_option = 3,
|
|
difficulty_option = 2,
|
|
-- mode_option = 'left',
|
|
endorserindices = { 2 },
|
|
name = "TestRun"
|
|
}
|
|
|
|
global_memory.crewproposals[#global_memory.crewproposals + 1] = proposal
|
|
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'lev',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Progression.go_from_currentdestination_to_sea()
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'hld',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Upgrades.execute_upgade(Upgrades.enum.EXTRA_HOLD)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'pwr',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Upgrades.execute_upgade(Upgrades.enum.MORE_POWER)
|
|
end
|
|
end)
|
|
|
|
|
|
commands.add_command(
|
|
'score',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
|
|
game.print('faking a highscore...')
|
|
Highscore.write_score(memory.secs_id, 'fakers', 0, 40, CoreData.version_string, 1, 1)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'scrget',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.print('running Highscore.load_in_scores()')
|
|
Highscore.load_in_scores()
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'tim',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Common.current_destination().dynamic_data.timer = 88
|
|
game.print('time set to 88 seconds')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'gld',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
memory.stored_fuel = memory.stored_fuel + 20000
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'bld',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
memory.classes_table = {[1] = 1}
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'rad',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Islands.spawn_enemy_boat(Boats.enum.RAFT)
|
|
local boat = memory.enemyboats[1]
|
|
Ai.spawn_boat_biters(boat, 0.89, Boats.get_scope(boat).Data.capacity, Boats.get_scope(boat).Data.width)
|
|
game.print('enemy boat spawned')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'rad2',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Islands.spawn_enemy_boat(Boats.enum.RAFTLARGE)
|
|
local boat = memory.enemyboats[1]
|
|
Ai.spawn_boat_biters(boat, 0.89, Boats.get_scope(boat).Data.capacity, Boats.get_scope(boat).Data.width)
|
|
game.print('large enemy boat spawned')
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'krk',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Memory.set_working_id(1)
|
|
local memory = Memory.get_crew_memory()
|
|
Kraken.try_spawn_kraken()
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'1/4',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 0.5
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'1/2',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 0.5
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'1',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 1
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'2',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 2
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'4',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 4
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'8',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 8
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'16',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 16
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'32',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 32
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'64',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
game.speed = 64
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ef1',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
Effects.worm_movement_effect(surface, {x = -45, y = 0}, false, true)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ef2',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
Effects.worm_movement_effect(surface, {x = -45, y = 0}, false, false)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ef3',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
Effects.worm_movement_effect(surface, {x = -45, y = 0}, true, false)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ef4',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
Effects.worm_emerge_effect(surface, {x = -45, y = 0})
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'ef5',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
cmd_set_memory(cmd)
|
|
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
local memory = Memory.get_crew_memory()
|
|
local surface = game.surfaces[Common.current_destination().surface_name]
|
|
Effects.biters_emerge(surface, {x = -30, y = 0})
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'emoji',
|
|
'is a dev command.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
Server.to_discord_embed_raw(CoreData.comfy_emojis.monkas)
|
|
end
|
|
end)
|
|
|
|
commands.add_command(
|
|
'piratux_test',
|
|
'is a dev command of piratux.',
|
|
function(cmd)
|
|
local param = tostring(cmd.parameter)
|
|
if check_admin(cmd) then
|
|
local player = game.players[cmd.player_index]
|
|
|
|
player.print('speed: ' .. player.character.speed .. 'effective_speed: ' .. player.character.effective_speed)
|
|
end
|
|
end)
|
|
end |