games/RedMew
games/RedMew
1
0
Fork 0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-12 10:04:40 +02:00
Code Issues Releases Activity

merged branches

Browse Source
This commit is contained in:
grilledham 2018-06-04 16:35:18 +01:00
commit 1520f95738
10 changed files with 188 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
custom_commands.lua
View File

@ -1,6 +1,8 @@
local Task = require 'utils.Task'
local Event = require 'utils.event'
local Token = require 'utils.global_token'
local UserGroups = require 'user_groups'
local Utils = require 'utils.utils'
function player_print(str)
if game.player then
@ -15,7 +17,7 @@ function cant_run(name)
end
local function invoke(cmd)
if not game.player or not (game.player.admin or is_mod(game.player.name)) then
if not (game.player and game.player.admin) then
cant_run(cmd.name)
return
end
@ -30,7 +32,7 @@ local function invoke(cmd)
end
local function teleport_player(cmd)
if not game.player or not (game.player.admin or is_mod(game.player.name)) then
if not (game.player and game.player.admin) then
cant_run(cmd.name)
return
end
@ -46,7 +48,7 @@ local function teleport_player(cmd)
end
local function teleport_location(cmd)
if not game.player or not (game.player.admin or is_mod(game.player.name)) then
if not (game.player and game.player.admin) then
cant_run(cmd.name)
return
end
@ -84,7 +86,7 @@ local custom_commands_return_player =
)
local function walkabout(cmd)
if not ((not game.player) or game.player.admin or is_mod(game.player.name)) then
if game.player and not game.player.admin then
cant_run(cmd.name)
return
end
@ -132,7 +134,7 @@ local function walkabout(cmd)
game.print(player_name .. ' went on a walkabout, to find himself.')
Task.set_timeout(
duration,
custom_commands_return_player,
'custom_commands_return_player',
{player = player, force = player.force, position = {x = player.position.x, y = player.position.y}}
)
player.character = nil
@ -146,39 +148,13 @@ local function walkabout(cmd)
end
local function regular(cmd)
if not ((not game.player) or game.player.admin or is_mod(game.player.name)) then
cant_run(cmd.name)
return
end
if cmd.parameter == nil then
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
end
local params = {}
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if params[2] == nil then
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
elseif (params[1] == 'promote') then
add_regular(params[2])
elseif (params[1] == 'demote') then
remove_regular(params[2])
else
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
end
end
local function mod(cmd)
if game.player and not game.player.admin then
cant_run(cmd.name)
return
end
if cmd.parameter == nil then
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
end
local params = {}
@ -186,14 +162,14 @@ local function mod(cmd)
table.insert(params, param)
end
if params[2] == nil then
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
elseif (params[1] == 'promote') then
add_mod(params[2])
UserGroups.add_regular(params[2])
elseif (params[1] == 'demote') then
remove_mod(params[2])
UserGroups.remove_regular(params[2])
else
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
end
end
@ -268,7 +244,7 @@ local function built_entity(event)
if global.tp_players[index] then
local entity = event.created_entity
if entity.type ~= 'entity-ghost' then
if not entity or not entity.valid or entity.type ~= 'entity-ghost' then
return
end
@ -280,7 +256,7 @@ end
Event.add(defines.events.on_built_entity, built_entity)
local function toggle_tp_mode(cmd)
if not game.player or not (game.player.admin or is_mod(game.player.name)) then
if not (game.player and game.player.admin) then
cant_run(cmd.name)
return
end
@ -300,7 +276,7 @@ end
global.old_force = {}
global.force_toggle_init = true
local function forcetoggle(cmd)
if not game.player or not (game.player.admin or is_mod(game.player.name)) or (not game.player.character) then
if not (game.player and game.player.admin and game.player.character) then
cant_run(cmd.name)
return
end
@ -322,6 +298,40 @@ local function forcetoggle(cmd)
end
end
if game.player.force.name == 'enemy' then
local old_force = global.old_force[game.player.name]
if not old_force then
game.player.force = 'player'
game.player.print("You're are now on the player force.")
else
if game.forces[old_force] then
game.player.force = old_force
else
game.player.force = 'player'
end
end
else
--Put roboports into inventory
inv = game.player.get_inventory(defines.inventory.player_armor)
if inv[1].valid_for_read then
local name = inv[1].name
if name:match('power') or name:match('modular') then
local equips = inv[1].grid.equipment
for _, equip in pairs(equips) do
if
equip.name == 'personal-roboport-equipment' or equip.name == 'personal-roboport-mk2-equipment' or
equip.name == 'personal-laser-defense-equipment'
then
if game.player.insert {name = equip.name} == 0 then
game.player.surface.spill_item_stack(game.player.position, {name = equip.name})
end
inv[1].grid.take(equip)
end
end
end
end
end
if game.player.force.name == 'enemy' then
local old_force = global.old_force[game.player.name]
if not old_force then
@ -369,22 +379,36 @@ local function forcetoggle(cmd)
end
end
local function get_group()
local group = game.permissions.get_group('Banned')
if not group then
game.permissions.create_group('Banned')
group = game.permissions.get_group('Banned')
if group then
for i = 2, 174 do
group.set_allows_action(i, false)
end
else
game.print(
'This would have nearly crashed the server, please consult the next best scenario dev (valansch or TWLtriston).'
)
local function tempban(cmd)
if (not game.player) or not game.player.admin then
cant_run(cmd.name)
return
end
if cmd.parameter == nil then
player_print('Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.')
return
end
local params = {}
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if #params < 2 or not tonumber(params[2]) then
player_print('Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.')
return
end
if not game.players[params[1]] then
player_print("Player doesn't exist.")
return
end
local group = get_group()
game.print(Utils.get_actor() .. ' put ' .. params[1] .. ' in timeout for ' .. params[2] .. ' minutes.')
if group then
group.add_player(params[1])
if not tonumber(cmd.parameter) then
Task.set_timeout(60 * tonumber(params[2]), 'custom_commands_untempban', {name = params[1]})
end
end
return group
end
local custom_commands_untempban =
@ -533,59 +557,20 @@ if not _DEBUG then
end
commands.add_command('kill', 'Will kill you.', kill)
commands.add_command('tpplayer', '<player> - Teleports you to the player. (Admins and moderators)', teleport_player)
commands.add_command('invoke', '<player> - Teleports the player to you. (Admins and moderators)', invoke)
commands.add_command('tpplayer', '<player> - Teleports you to the player. (Admins only)', teleport_player)
commands.add_command('invoke', '<player> - Teleports the player to you. (Admins only)', invoke)
commands.add_command('tppos', 'Teleports you to a selected entity. (Admins only)', teleport_location)
commands.add_command('walkabout', '<player> <duration> - Send someone on a walk. (Admins and moderators)', walkabout)
commands.add_command('regulars', 'Prints a list of game regulars.', print_regulars)
commands.add_command(
'regular',
'<promote, demote>, <player> Change regular status of a player. (Admins and moderators)',
regular
)
commands.add_command('mods', 'Prints a list of game mods.', print_mods)
commands.add_command('mod', '<promote, demote>, <player> Changes moderator status of a player. (Admins only)', mod)
commands.add_command('walkabout', '<player> <duration> - Send someone on a walk. (Admins only)', walkabout)
commands.add_command('regulars', 'Prints a list of game regulars.', UserGroups.print_regulars)
commands.add_command('regular', '<promote, demote>, <player> Change regular status of a player. (Admins only)', regular)
commands.add_command('afk', 'Shows how long players have been afk.', afk)
--commands.add_command("tag", '<player> <tag> Sets a players tag. (Admins only)', tag)
commands.add_command(
'follow',
'<player> makes you follow the player. Use /unfollow to stop following a player.',
follow
)
commands.add_command('follow', '<player> makes you follow the player. Use /unfollow to stop following a player.', follow)
commands.add_command('unfollow', 'stops following a player.', unfollow)
commands.add_command(
'tpmode',
'Toggles tp mode. When on place a ghost entity to teleport there (Admins and moderators)',
toggle_tp_mode
)
commands.add_command(
'forcetoggle',
'Toggles the players force between player and enemy (Admins and moderators)',
forcetoggle
)
commands.add_command('tempban', '<player> <minutes> Temporarily bans a player (Admins and moderators)', tempban)
commands.add_command(
'spyshot',
'<player> Sends a screenshot of player to discord. (If a host is online. If no host is online, you can become one yourself. Ask on discord :))',
spyshot
)
commands.add_command('tpmode', 'Toggles tp mode. When on place a ghost entity to teleport there (Admins only)', toggle_tp_mode)
commands.add_command('forcetoggle', 'Toggles the players force between player and enemy (Admins only)', forcetoggle)
commands.add_command('tempban', '<player> <minutes> Temporarily bans a player (Admins only)', tempban)
commands.add_command('spyshot', '<player> Sends a screenshot of player to discord. (If a host is online. If no host is online, you can become one yourself. Ask on discord :))', spyshot)
commands.add_command('zoom', '<number> Sets your zoom.', zoom)
commands.add_command(
'all-tech',
'researches all technologies',
function()
if game.player and game.player.admin then
game.player.force.research_all_technologies()
end
end
)
commands.add_command(
'hax',
'Toggles your hax',
function()
if game.player and game.player.admin then
game.player.cheat_mode = not game.player.cheat_mode
end
end
)
commands.add_command('all-tech', 'researches all technologies', function() if game.player and game.player.admin then game.player.force.research_all_technologies() end end)
commands.add_command('hax', 'Toggles your hax', function() if game.player and game.player.admin then game.player.cheat_mode = not game.player.cheat_mode end end)
commands.add_command('pool', 'Spawns a pool', pool)

8
follow.lua
View File

@ -1,5 +1,6 @@
global.follows = {}
global.follows.n_entries = 0
local Utils = require "utils.utils"
function get_direction(follower, target)
local delta_x = target.position.x - follower.position.x
@ -37,18 +38,13 @@ function get_direction(follower, target)
end
end
local function distance(player_1, player_2)
local d_x = player_1.position.x - player_2.position.x
local d_y = player_1.position.y - player_2.position.y
return math.sqrt(d_x*d_x + d_y * d_y)
end
function walk_on_tick()
if global.follows.n_entries > 0 then
for k,v in pairs(global.follows) do
local follower = game.players[k]
local target = game.players[v]
if follower ~= nil and target ~= nil then
local d = distance(follower, target)
local d = Utils.distance(follower, target)
if follower.connected and target.connected and d < 32 then
if d > 5 then
direction = get_direction(follower, target)

25
map_gen/ores/rso/rso_control.lua
View File

@ -3,6 +3,7 @@
require("rso_config")
require("util")
require("rso_resource_config")
local Utils = require "utils.utils"
local MB=require "metaball"
local drand = require 'drand'
@ -28,13 +29,9 @@ local sin = math.sin
local pi = math.pi
local max = math.max
local function round(value)
return math.floor(value + 0.5)
end
local function rso_debug(str)
if rso_debug_enabled then
if ( type(str) == "table") then
if (type(str) == "table") then
game.players[1].print(serpent.dump(str))
else
game.players[1].print(str)
@ -381,7 +378,7 @@ local function spawn_resource_ore(surface, rname, pos, size, richness, startingA
local dev_x, dev_y = pos.x, pos.y
x = rgen:random(-dev, dev)+dev_x
y = rgen:random(-dev, dev)+dev_y
if p_balls[#p_balls] and distance(p_balls[#p_balls], {x=x, y=y}) < MIN_BALL_DISTANCE then
if p_balls[#p_balls] and Utils.distance(p_balls[#p_balls], {x=x, y=y}) < MIN_BALL_DISTANCE then
local new_angle = bearing(p_balls[#p_balls], {x=x, y=y})
rso_debug("Move ball old xy @ "..x..","..y)
x=(cos(new_angle)*MIN_BALL_DISTANCE) + x
@ -761,8 +758,8 @@ local function spawn_starting_resources( surface, index )
end
local function modifyMinMax(value, mod)
value.min = round( value.min * mod )
value.max = round( value.max * mod )
value.min = math.round( value.min * mod )
value.max = math.round( value.max * mod )
end
local function prebuild_config_data(surface)
@ -818,7 +815,7 @@ local function prebuild_config_data(surface)
res_conf.absolute_probability = res_conf.absolute_probability * allotmentMod
rso_debug("Entity chance modified to "..res_conf.absolute_probability)
else
res_conf.allotment = round( res_conf.allotment * allotmentMod )
res_conf.allotment = math.round( res_conf.allotment * allotmentMod )
end
end
@ -830,7 +827,7 @@ local function prebuild_config_data(surface)
modifyMinMax(res_conf.size, sizeMod)
if res_conf.starting then
res_conf.starting.size = round( res_conf.starting.size * sizeMod )
res_conf.starting.size = math.round( res_conf.starting.size * sizeMod )
end
if isEntity then
@ -843,13 +840,13 @@ local function prebuild_config_data(surface)
if richnessMod then
if type == "resource-ore" then
res_conf.richness = round( res_conf.richness * richnessMod )
res_conf.richness = math.round( res_conf.richness * richnessMod )
elseif type == "resource-liquid" then
modifyMinMax(res_conf.richness, richnessMod)
end
if res_conf.starting then
res_conf.starting.richness = round( res_conf.starting.richness * richnessMod )
res_conf.starting.richness = math.round( res_conf.starting.richness * richnessMod )
end
end
end
@ -1018,7 +1015,7 @@ local function roll_region(c_x, c_y)
if v.absolute_probability then
local prob_factor = 1
if v.probability_distance_factor then
prob_factor = math.min(v.max_probability_distance_factor, v.probability_distance_factor^distance({x=0,y=0},{x=r_x,y=r_y}))
prob_factor = math.min(v.max_probability_distance_factor, v.probability_distance_factor^Utils.distance({x=0,y=0},{x=r_x,y=r_y}))
end
local abs_roll = rgen:random()
if abs_roll<v.absolute_probability*prob_factor then
@ -1074,7 +1071,7 @@ local function roll_chunk(surface, c_x, c_y)
local deep = res_con[2]
local r_config = config[resource]
if r_config and r_config.valid then
local dist = distance({x=0,y=0},{x=r_x,y=r_y})
local dist = Utils.distance({x=0,y=0},{x=r_x,y=r_y})
local sizeFactor = dist^size_distance_factor
if r_config.type=="resource-ore" then
local richFactor = dist^richness_distance_factor

28
map_gen/presets/mobius_strip.lua
View File

@ -1,6 +1,6 @@
local Event = require "utils.event"
local Event = require 'utils.event'
local b = require "map_gen.shared.builders"
local b = require 'map_gen.shared.builders'
local inner_circle = b.invert(b.circle(48))
local outer_circle = b.circle(64)
@ -26,11 +26,10 @@ local map = b.any({half, b.flip_xy(half)})
map = b.scale(map, 11, 11)
local function research_finished(event)
local tech = event.research.name
if tech == "rocket-silo" then
game.forces["player"].recipes["rocket-silo"].enabled = false
if tech == 'rocket-silo' then
game.forces['player'].recipes['rocket-silo'].enabled = false
end
end
@ -39,7 +38,7 @@ Event.add(defines.events.on_research_finished, research_finished)
local function max_axis_distance(world_x, world_y, target_x, target_y)
local x = math.abs(world_x - target_x)
local y = math.abs(world_y - target_y)
return math.max(x, y)
end
@ -50,22 +49,21 @@ end
local init = false
local safe_distance = 480
local function effect(x, y, world, tile)
if not init then
init = true
game.forces["player"].chart(world.surface, {{-32, -32}, {31, 31}})
game.forces['player'].chart(world.surface, {{-32, -32}, {31, 31}})
end
if world.x == 0 and world.y == 0 then
for _, e in ipairs(world.surface.find_entities({{-5, -5}, {5, 5}})) do
e.destroy()
end
local e = world.surface.create_entity({name = "rocket-silo", position = {0, 0}, force = "player"})
local e = world.surface.create_entity({name = 'rocket-silo', position = {0, 0}, force = 'player'})
e.destructible = false
e.minable = false
end
--[[
if max_axis_distance(world_x, world_y, -2144, 0) < safe_distance then
@ -107,8 +105,8 @@ end
map = b.apply_effect(map, effect)
require "spawn_control"
add_spawn("left", -88, -88)
add_spawn("right", 88, 88)
require 'spawn_control'
add_spawn('left', -88, -88)
add_spawn('right', 88, 88)
return map

54
nuke_control.lua
View File

@ -1,14 +1,15 @@
local Event = require "utils.event"
local UserGroups = require "user_groups"
local Utils = require "utils.utils"
function allowed_to_nuke(player)
if type(player) == "table" then
return player.admin or is_mod(player.name) or is_regular(player.name) or ((player.online_time / 216000) > global.scenario.config.nuke_min_time_hours)
return player.admin or UserGroups.is_regular(player.name) or ((player.online_time / 216000) > global.scenario.config.nuke_min_time_hours)
elseif type(player) == "number" then
return allowed_to_nuke(game.players[player])
end
end
local function ammo_changed(event)
local player = game.players[event.player_index]
if allowed_to_nuke(player) then return end
@ -19,20 +20,19 @@ local function ammo_changed(event)
end
end
local function on_player_deconstructed_area(event)
local player = game.players[event.player_index]
if allowed_to_nuke(player) then return end
local nukes = player.remove_item({name="deconstruction-planner", count=1000})
--Make them think they arent noticed
print_except(player.name .. " tried to deconstruct something, but instead deconstructed himself.", player)
Utils.print_except(player.name .. " tried to deconstruct something, but instead deconstructed themself.", player)
player.print("Only regulars can mark things for deconstruction, if you want to deconstruct something you may ask an admin to promote you.")
player.character.health = 0
local entities = player.surface.find_entities_filtered{area = event.area, force = player.force}
if #entities > 1000 then
print_admins("Warning! " .. player.name .. " just tried to deconstruct " .. tostring(#entities) .. " entities!")
Utils.print_admins("Warning! " .. player.name .. " just tried to deconstruct " .. tostring(#entities) .. " entities!")
end
for _,entity in pairs(entities) do
if entity.valid and entity.to_be_deconstructed(game.players[event.player_index].force) then
@ -41,45 +41,12 @@ local function on_player_deconstructed_area(event)
end
end
local function log_on_player_mined_entity(str, event)
game.write_file("on_player_mined_entity_debug", game.tick .. " (" .. game.players[event.player_index].name .. ") " .. str .. "\n", true, 0)
end
global.on_player_mined_item_enabled = true
global.on_player_mined_item_init = true
--Never knew the debug code made it into the codebase lol
local function on_player_mined_item(event)
log_on_player_mined_entity("nuke_control.on_player_mined_item: entry", event)
if global.on_player_mined_item_enabled then
log_on_player_mined_entity("nuke_control.on_player_mined_item: enabled", event)
if global.on_player_mined_item_init then
log_on_player_mined_entity("nuke_control.on_player_mined_item: init", event)
game.forces.enemy.research_all_technologies() --avoids losing logstics slot configuration on force toggle
global.on_player_mined_item_init = false
end
local entity = event.entity
if entity.valid and entity.force.name ~= "enemy" and entity.force.name ~= "neutral" and entity.name ~= "entity-ghost" and entity.type ~= "logistic-robot" and entity.type ~= "construction-robot" then
log_on_player_mined_entity("nuke_control.on_player_mined_item: in body", event)
local entity_name = entity.name
if entity_name == "pipe-to-ground" then entity_name = "pipe" end
log_on_player_mined_entity("nuke_control.on_player_mined_item: before ghost placement", event)
local ghost = event.entity.surface.create_entity{name = "entity-ghost", position = event.entity.position, inner_name = entity_name, expires = false, force = "enemy", direction = event.entity.direction}
log_on_player_mined_entity("nuke_control.on_player_mined_item: ghost placed", event)
ghost.last_user = event.player_index
log_on_player_mined_entity("nuke_control.on_player_mined_item: last user set", event)
end
end
log_on_player_mined_entity("nuke_control.on_player_mined_item: exit", event)
end
local function item_not_sanctioned(item)
local name = item.name
return (
name:find("capsule") or
name == "cliff-explosives" or
name == "raw-fish" or
name:find("capsule") or
name == "cliff-explosives" or
name == "raw-fish" or
name == "discharge-defense-remote"
)
end
@ -103,8 +70,8 @@ local function on_capsule_used(event)
local area = {{event.position.x-5, event.position.y-5}, {event.position.x+5, event.position.y+5}}
local count = 0
local entities = player.surface.find_entities_filtered{force=player.force, area=area}
for _,e in pairs(entities) do
if not entity_allowed_to_bomb(e) then count = count + 1 end
for _,e in pairs(entities) do
if not entity_allowed_to_bomb(e) then count = count + 1 end
end
if count > 8 then
if global.players_warned[event.player_index] then
@ -121,4 +88,3 @@ Event.add(defines.events.on_player_ammo_inventory_changed, ammo_changed)
Event.add(defines.events.on_player_deconstructed_area, on_player_deconstructed_area)
--Event.add(defines.events.on_player_mined_entity, on_player_mined_item)
Event.add(defines.events.on_player_used_capsule, on_capsule_used)

2
player_list.lua
View File

@ -277,7 +277,7 @@ local function player_list_show(player, sort_by)
label.style.minimal_width = 130
label.style.maximal_width = 130
local label = player_list_panel_table.add { type = "label", name = "player_list_panel_player_distance_" .. i, caption = round(global.player_walk_distances[player_list[i].name]/1000, 1) .. " km" }
local label = player_list_panel_table.add { type = "label", name = "player_list_panel_player_distance_" .. i, caption = math.round(global.player_walk_distances[player_list[i].name]/1000, 1) .. " km" }
label.style.minimal_width = 100
label.style.maximal_width = 100

4
poll.lua
View File

@ -35,7 +35,7 @@ local function poll_show(player)
local x = game.tick
x = ((x / 60) / 60) / 60
x = global.score_total_polls_created / x
x = round(x, 0)
x = math.round(x)
str = str .. " (Polls/hour: "
str = str .. x
str = str .. ")"
@ -304,7 +304,7 @@ function on_second()
if frame then
local y = (game.tick - global.poll_panel_creation_time[player.index]) / 60
local y = global.poll_duration_in_seconds - y
y = round(y, 0)
y = math.round(y)
if y <= 0 then
frame.destroy()
global.poll_panel_creation_time[player.index] = nil

12
resources/mods.lua
View File

@ -1,12 +0,0 @@
return {
['dpoba'] = true,
['masjazz'] = true,
['mbas'] = true,
['selen'] = true,
['sholvo'] = true,
['animal'] = true,
['terarink'] = true,
['theorangeangle'] = true,
['fabilord98'] = true,
['rickeyhb'] = true
}

112
user_groups.lua
View File

@ -1,89 +1,63 @@
global.regulars = require "resources.regulars"
global.mods = require "resources.mods"
local Event = require "utils.event"
local Utils = require "utils.utils"
function update_group(position)
local file = position .. ".lua"
local Module = {}
local function update_file()
local file = "regulars.lua"
game.write_file(file, "{", false, 0)
local group = global[position]
local line = ""
for player_name, _ in pairs(group) do
for player_name,_ in pairs(global.regulars) do
line = string.format('["%s"] = true,\n', player_name)
game.write_file(file, line, true, 0)
end
game.write_file(file, "}", true, 0)
end
function get_actor()
if game.player then
return game.player.name
end
return "<server>"
Module.is_regular = function(player_name)
return Utils.cast_bool(global.regulars[player_name] or global.regulars[player_name:lower()]) --to make it backwards compatible
end
Module.add_regular = function(player_name)
local actor = Utils.get_actor()
if Module.is_regular(player_name) then player_print(player_name .. " is already a regular.")
else
if game.players[player_name] then
player_name = game.players[player_name].name
game.print(actor .. " promoted " .. player_name .. " to regular.")
global.regulars[player_name] = true
update_file()
else
player_print(player_name .. " does not exist.")
end
end
end
function is_mod(player_name)
return global.mods[player_name:lower()]
end
function is_regular(player_name)
return global.regulars[player_name:lower()]
end
function add_regular(player_name)
local actor = get_actor()
if is_regular(player_name) then
player_print(player_name .. " is already a regular.")
else
if game.players[player_name] then
game.print(actor .. " promoted " .. player_name .. " to regular.")
global.regulars[player_name:lower()] = ""
update_group("regulars")
else
player_print(player_name .. " does not exist.")
end
end
end
function add_mod(player_name)
local actor = get_actor()
if is_mod(player_name) then
player_print(player_name .. " is already a moderator.")
else
if game.players[player_name] then
game.print(actor .. " promoted " .. player_name .. " to moderator.")
global.mods[player_name:lower()] = ""
update_group("mods")
else
player_print(player_name .. " does not exist.")
end
end
end
function remove_regular(player_name)
local actor = get_actor()
if is_regular(player_name) then
game.print(player_name .. " was demoted from regular by " .. actor .. ".")
end
Module.remove_regular = function(player_name)
local actor = Utils.get_actor()
if game.players[player_name] then
player_name = game.players[player_name].name
if Module.is_regular(player_name) then game.print(player_name .. " was demoted from regular by " .. actor .. ".") end
global.regulars[player_name] = nil
update_group("regulars")
global.regulars[player_name:lower()] = nil --backwards compatible
update_file()
end
end
function remove_mod(player_name)
local actor = get_actor()
if is_mod(player_name) then
game.print(player_name .. " was demoted from mod by " .. actor .. ".")
end
global.mods[player_name] = nil
update_group("mods")
end
function print_regulars()
for k, _ in pairs(global.regulars) do
Module.print_regulars = function()
for k,_ in pairs(global.regulars) do
player_print(k)
end
end
function print_mods()
for k, _ in pairs(global.mods) do
player_print(k)
Event.add(defines.events.on_player_joined_game, function(event)
local correctCaseName = game.players[event.player_index].name
if global.regulars[correctCaseName:lower()] and not global.regulars[correctCaseName] then
global.regulars[correctCaseName:lower()] = nil
global.regulars[correctCaseName] = true
update_file()
end
end
end)
return Module

492
utils/utils.lua
View File

@ -1,487 +1,18 @@
-- utils.lua by binbinhfr, v1.0.16
-- A 3Ra Gaming revision
-- define debug_status to 1 or nil in the control.lua, before statement require("utils")
-- define also debug_file and debug_mod_name
local Module = {}
local Event = require "utils.event"
colors = {
white = { r = 1, g = 1, b = 1 },
black = { r = 0, g = 0, b = 0 },
darkgrey = { r = 0.25, g = 0.25, b = 0.25 },
grey = { r = 0.5, g = 0.5, b = 0.5 },
lightgrey = { r = 0.75, g = 0.75, b = 0.75 },
red = { r = 1, g = 0, b = 0 },
darkred = { r = 0.5, g = 0, b = 0 },
lightred = { r = 1, g = 0.5, b = 0.5 },
green = { r = 0, g = 1, b = 0 },
darkgreen = { r = 0, g = 0.5, b = 0 },
lightgreen = { r = 0.5, g = 1, b = 0.5 },
blue = { r = 0, g = 0, b = 1 },
darkblue = { r = 0, g = 0, b = 0.5 },
lightblue = { r = 0.5, g = 0.5, b = 1 },
orange = { r = 1, g = 0.55, b = 0.1 },
yellow = { r = 1, g = 1, b = 0 },
pink = { r = 1, g = 0, b = 1 },
purple = { r = 0.6, g = 0.1, b = 0.6 },
brown = { r = 0.6, g = 0.4, b = 0.1 },
}
anticolors = {
white = colors.black,
black = colors.white,
darkgrey = colors.white,
grey = colors.black,
lightgrey = colors.black,
red = colors.white,
darkred = colors.white,
lightred = colors.black,
green = colors.black,
darkgreen = colors.white,
lightgreen = colors.black,
blue = colors.white,
darkblue = colors.white,
lightblue = colors.black,
orange = colors.black,
yellow = colors.black,
pink = colors.white,
purple = colors.white,
brown = colors.white,
}
lightcolors = {
white = colors.lightgrey,
grey = colors.darkgrey,
lightgrey = colors.grey,
red = colors.lightred,
green = colors.lightgreen,
blue = colors.lightblue,
yellow = colors.orange,
pink = colors.purple,
}
local author_name1 = "BinbinHfr"
local author_name2 = "binbin"
--------------------------------------------------------------------------------------
function read_version(v)
local v1, v2, v3 = string.match(v, "(%d+).(%d+).(%d+)")
debug_print("version cut = ", v1, v2, v3)
end
--------------------------------------------------------------------------------------
function compare_versions(v1, v2)
local v1a, v1b, v1c = string.match(v1, "(%d+).(%d+).(%d+)")
local v2a, v2b, v2c = string.match(v2, "(%d+).(%d+).(%d+)")
v1a = tonumber(v1a)
v1b = tonumber(v1b)
v1c = tonumber(v1c)
v2a = tonumber(v2a)
v2b = tonumber(v2b)
v2c = tonumber(v2c)
if v1a > v2a then
return 1
elseif v1a < v2a then
return -1
elseif v1b > v2b then
return 1
elseif v1b < v2b then
return -1
elseif v1c > v2c then
return 1
elseif v1c < v2c then
return -1
else
return 0
end
end
--------------------------------------------------------------------------------------
function older_version(v1, v2)
local v1a, v1b, v1c = string.match(v1, "(%d+).(%d+).(%d+)")
local v2a, v2b, v2c = string.match(v2, "(%d+).(%d+).(%d+)")
local ret
v1a = tonumber(v1a)
v1b = tonumber(v1b)
v1c = tonumber(v1c)
v2a = tonumber(v2a)
v2b = tonumber(v2b)
v2c = tonumber(v2c)
if v1a > v2a then
ret = false
elseif v1a < v2a then
ret = true
elseif v1b > v2b then
ret = false
elseif v1b < v2b then
ret = true
elseif v1c < v2c then
ret = true
else
ret = false
end
debug_print("older_version ", v1, "<", v2, "=", ret)
return (ret)
end
--------------------------------------------------------------------------------------
function debug_active(...)
-- can be called everywhere, except in on_load where game is not existing
local s = ""
for i, v in ipairs({ ... }) do
s = s .. tostring(v)
end
if s == "RAZ" or debug_do_raz == true then
game.remove_path(debug_file)
debug_do_raz = false
elseif s == "CLEAR" then
for _, player in pairs(game.players) do
if player.connected then player.clear_console() end
end
end
s = debug_mod_name .. "(" .. game.tick .. "): " .. s
game.write_file(debug_file, s .. "\n", true)
for _, player in pairs(game.players) do
if player.connected then player.print(s) end
end
end
if debug_status == 1 then debug_print = debug_active else debug_print = function() end end
--------------------------------------------------------------------------------------
function message_all(s)
for _, player in pairs(game.players) do
if player.connected then
player.print(s)
end
end
end
--------------------------------------------------------------------------------------
function message_force(force, s)
for _, player in pairs(force.players) do
if player.connected then
player.print(s)
end
end
end
--------------------------------------------------------------------------------------
function square_area(origin, radius)
return {
{ x = origin.x - radius, y = origin.y - radius },
{ x = origin.x + radius, y = origin.y + radius }
}
end
--------------------------------------------------------------------------------------
function distance(pos1, pos2)
Module.distance = function(pos1, pos2)
local dx = pos2.x - pos1.x
local dy = pos2.y - pos1.y
return (math.sqrt(dx * dx + dy * dy))
return math.sqrt(dx * dx + dy * dy)
end
--------------------------------------------------------------------------------------
function distance_square(pos1, pos2)
return (math.max(math.abs(pos2.x - pos1.x), math.abs(pos2.y - pos1.y)))
end
--------------------------------------------------------------------------------------
function pos_offset(pos, offset)
return { x = pos.x + offset.x, y = pos.y + offset.y }
end
--------------------------------------------------------------------------------------
function surface_area(surf)
local x1, y1, x2, y2 = 0, 0, 0, 0
for chunk in surf.get_chunks() do
if chunk.x < x1 then
x1 = chunk.x
elseif chunk.x > x2 then
x2 = chunk.x
end
if chunk.y < y1 then
y1 = chunk.y
elseif chunk.y > y2 then
y2 = chunk.y
end
end
return ({ { x1 * 32 - 8, y1 * 32 - 8 }, { x2 * 32 + 40, y2 * 32 + 40 } })
end
--------------------------------------------------------------------------------------
function iif(cond, val1, val2)
if cond then
return val1
else
return val2
end
end
--------------------------------------------------------------------------------------
function add_list(list, obj)
-- to avoid duplicates...
for i, obj2 in pairs(list) do
if obj2 == obj then
return (false)
end
end
table.insert(list, obj)
return (true)
end
--------------------------------------------------------------------------------------
function del_list(list, obj)
for i, obj2 in pairs(list) do
if obj2 == obj then
table.remove(list, i)
return (true)
end
end
return (false)
end
--------------------------------------------------------------------------------------
function in_list(list, obj)
for k, obj2 in pairs(list) do
if obj2 == obj then
return (k)
end
end
return (nil)
end
--------------------------------------------------------------------------------------
function size_list(list)
local n = 0
for i in pairs(list) do
n = n + 1
end
return (n)
end
--------------------------------------------------------------------------------------
function concat_lists(list1, list2)
-- add list2 into list1 , do not avoid duplicates...
for i, obj in pairs(list2) do
table.insert(list1, obj)
end
end
------------------------------------------------------------------------------------
function is_dev(player)
return (player.name == author_name1 or player.name == author_name2)
end
--------------------------------------------------------------------------------------
function dupli_proto(type, name1, name2)
if data.raw[type][name1] then
local proto = table.deepcopy(data.raw[type][name1])
proto.name = name2
if proto.minable and proto.minable.result then proto.minable.result = name2 end
if proto.place_result then proto.place_result = name2 end
if proto.take_result then proto.take_result = name2 end
if proto.result then proto.result = name2 end
return (proto)
else
error("prototype unknown " .. name1)
return (nil)
end
end
--------------------------------------------------------------------------------------
function debug_guis(guip, indent)
if guip == nil then return end
debug_print(indent .. string.rep("....", indent) .. " " .. guip.name)
indent = indent + 1
for k, gui in pairs(guip.children_names) do
debug_guis(guip[gui], indent)
end
end
--------------------------------------------------------------------------------------
function extract_monolith(filename, x, y, w, h)
return {
type = "monolith",
top_monolith_border = 0,
right_monolith_border = 0,
bottom_monolith_border = 0,
left_monolith_border = 0,
monolith_image = {
filename = filename,
priority = "extra-high-no-scale",
width = w,
height = h,
x = x,
y = y,
},
}
end
--------------------------------------------------------------------------------------
-- rounds number (num) to certain number of decimal places (idp)
function round(num, idp)
math.round = function(num, idp)
local mult = 10 ^ (idp or 0)
return math.floor(num * mult + 0.5) / mult
end
-- cleans up the color values, gets rid of floating point innacuracy
function clean_color(input_color)
local temp_r = round(input_color.r, 6)
local temp_g = round(input_color.g, 6)
local temp_b = round(input_color.b, 6)
local temp_a = round(input_color.a, 6)
return { r = temp_r, g = temp_g, b = temp_b, a = temp_a }
end
--------------------------------------------------------------------------------------
-- returns true if colors are the same, false if different
function compare_colors(color1, color2)
local clean_color1 = clean_color(color1)
local clean_color2 = clean_color(color2)
if clean_color1.r ~= clean_color2.r then
return false
end
if clean_color1.g ~= clean_color2.g then
return false
end
if clean_color1.b ~= clean_color2.b then
return false
end
if clean_color1.a ~= clean_color2.a then
return false
end
return true
end
--------------------------------------------------------------------------------------
-- Provide a player's name to put their inventory into a chest somewhere near spawn.
function return_inventory(player_name)
local success, err = pcall(return_inventory_p, player_name)
if not success then
game.print(err)
return
end
if err then
return
end
end
function return_inventory_p(player_name)
local stolen_inventories = {
main = game.players[player_name].get_inventory(defines.inventory.player_main),
quickbar = game.players[player_name].get_inventory(defines.inventory.player_quickbar),
guns = game.players[player_name].get_inventory(defines.inventory.player_guns),
ammo = game.players[player_name].get_inventory(defines.inventory.player_ammo),
armor = game.players[player_name].get_inventory(defines.inventory.player_armor),
tools = game.players[player_name].get_inventory(defines.inventory.player_tools),
vehicle = game.players[player_name].get_inventory(defines.inventory.player_vehicle),
trash = game.players[player_name].get_inventory(defines.inventory.player_trash)
}
local chest_location = game.surfaces.nauvis.find_non_colliding_position("steel-chest", game.forces.player.get_spawn_position(game.surfaces.nauvis), 0, 1)
local return_chest = game.surfaces.nauvis.create_entity{name = "steel-chest", position = chest_location, force = game.forces.player}
local chest_inventory = return_chest.get_inventory(defines.inventory.chest)
for _,inventory in pairs(stolen_inventories) do
for name,count in pairs(inventory.get_contents()) do
local inserted = chest_inventory.insert{name = name, count = count}
if inserted > 0 then
inventory.remove{name = name, count = inserted}
end
if inserted < count then
chest_location = game.surfaces.nauvis.find_non_colliding_position("steel-chest", chest_location, 0, 1)
chest_inventory = game.surfaces.nauvis.create_entity{name = "steel-chest", position = chest_location, force = game.forces.player}
inserted = chest_inventory.insert{name = name, count = (count - inserted)}
if inserted > 0 then
inventory.remove{name = name, count = inserted}
end
end
end
end
game.print("The now banned griefer " .. player_name .. "'s inventory has been returned somewhere near the spawn. Look for one or more steel chests.")
end
--------------------------------------------------------------------------------------
-- Currently console only, as print() is used to print the results
function show_inventory(player_name)
local success, err = pcall(show_inventory_p, player_name)
if not success then
game.print(err)
return
end
if err then
return
end
end
function show_inventory_p(player_name)
local player = game.players[player_name]
local inventories = {
main = game.players[player_name].get_inventory(defines.inventory.player_main),
quickbar = game.players[player_name].get_inventory(defines.inventory.player_quickbar),
guns = game.players[player_name].get_inventory(defines.inventory.player_guns),
ammo = game.players[player_name].get_inventory(defines.inventory.player_ammo),
armor = game.players[player_name].get_inventory(defines.inventory.player_armor),
tools = game.players[player_name].get_inventory(defines.inventory.player_tools),
vehicle = game.players[player_name].get_inventory(defines.inventory.player_vehicle),
trash = game.players[player_name].get_inventory(defines.inventory.player_trash)
}
for invname,inventory in pairs(inventories) do
if not inventory.is_empty() then print("Items in " .. invname .. " inventory:") end
for name,count in pairs(inventory.get_contents()) do
print(" " .. name .. " - " .. count)
end
end
end
--------------------------------------------------------------------------------------
--This command simply deletes the inventory of the listed player
function delete_inventory(player_name)
local success, err = pcall(delete_inventory_p, player_name)
if not success then
game.print(err)
return
end
if err then
return
end
end
function delete_inventory_p(player_name)
local stolen_inventories = {
main = game.players[player_name].get_inventory(defines.inventory.player_main),
quickbar = game.players[player_name].get_inventory(defines.inventory.player_quickbar),
guns = game.players[player_name].get_inventory(defines.inventory.player_guns),
ammo = game.players[player_name].get_inventory(defines.inventory.player_ammo),
armor = game.players[player_name].get_inventory(defines.inventory.player_armor),
tools = game.players[player_name].get_inventory(defines.inventory.player_tools),
vehicle = game.players[player_name].get_inventory(defines.inventory.player_vehicle),
trash = game.players[player_name].get_inventory(defines.inventory.player_trash)
}
for _,inventory in pairs(stolen_inventories) do
for name,count in pairs(inventory.get_contents()) do
inventory.remove{name = name, count = count}
end
end
end
--------------------------------------------------------------------------------------
--Send chat only to a specific force
--name can be either the name of a player or the name of a force
--message is the actual message to send
function force_chat(name, message)
local force
if game.players[name] then force = game.players[name].force
else force = game.forces[name] end
if force then force.print("[WEB] " .. message) end
end
function print_except(msg, player)
Module.print_except = function(msg, player)
for _,p in pairs(game.players) do
if p.connected and p ~= player then
p.print(msg)
@ -489,10 +20,21 @@ function print_except(msg, player)
end
end
function print_admins(msg)
Module.print_admins = function(msg)
for _,p in pairs(game.players) do
if p.connected and p.admin then
p.print(msg)
end
end
end
Module.get_actor = function()
if game.player then return game.player.name end
return "<server>"
end
Module.cast_bool = function(var)
if var then return true else return false end
end
return Module