Cleanup up utils

custom_commands.lua

@@ -1,6 +1,7 @@
 local Task = require "utils.Task"
 local Event = require "utils.event"
 local UserGroups = require "user_groups"
+local Utils = require "utils.utils"
 
 function player_print(str)
   if game.player then
@@ -367,7 +368,7 @@ local function tempban(cmd)
   end
   local group = get_group()
 
-  game.print(get_actor() .. " put " .. params[1] .. " in timeout for " .. params[2] .. " minutes.")
+  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

follow.lua

@@ -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)

map_gen/ores/rso/rso_control.lua

@@ -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.min = math.round( value.min * mod )
-   value.max = round( value.max * 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

map_gen/presets/mobius_strip.lua

@@ -48,10 +48,6 @@ local function max_axis_distance(world_x, world_y, target_x, target_y)
     return math.max(x, y)
 end
 
-local function distance(world_x, world_y, target_x, target_y)
-    return math.abs(world_x - target_x) + math.abs(world_y - target_y)
-end
-
 local init = false
 local safe_distance = 480
 local function effect(x, y, world_x, world_y, tile, entity, surface)
@@ -70,43 +66,6 @@ local function effect(x, y, world_x, world_y, tile, entity, surface)
         e.destructible = false
         e.minable = false
     end
-    
-    --[[
-    
-    if max_axis_distance(world_x, world_y, -2144, 0) < safe_distance then
-    for _, e in ipairs(surface.find_entities_filtered({ force = "enemy", position = { world_x, world_y } } )) do
-    e.destroy()
-    end
-    elseif max_axis_distance(world_x, world_y, 2144, 0) < safe_distance then
-    for _, e in ipairs(surface.find_entities_filtered({ force = "enemy", position = { world_x, world_y } } )) do
-    e.destroy()
-    end
-    end
-    
-    for _, e in ipairs(surface.find_entities_filtered({ type = "resource", area = {{world_x, world_y  }, {world_x + 1, world_y + 1 } } })) do -- I want to use position but for some reason it doesn't seem to work for ores.
-    local dist1 = distance(world_x, world_y, -2144, 0)
-    local dist2 = distance(world_x, world_y, 2144, 0)
-    local amount = math.min(dist1, dist2)
-    
-    local name = e.name
-    if name == "iron-ore" then
-    amount = 800 + 0.4 * amount
-    elseif name == "copper-ore" then
-    amount = 700 + 0.35 * amount
-    elseif name == "coal" then
-    amount = 600 + 0.3 * amount
-    elseif name == "stone" then
-    amount = 400 + 0.2 * amount
-    elseif name == "uranium-ore" then
-    amount = 300 + 0.15 * amount
-    elseif name == "crude-oil" then
-    amount = 50000 + 50 * amount
-    end
-    
-    e.amount = amount
-    end
-    
-    --]]
     return tile, entity
 end
 

nuke_control.lua

@@ -1,5 +1,6 @@
 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
@@ -25,13 +26,13 @@ local function on_player_deconstructed_area(event)
     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 himself.", 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

player_list.lua

@@ -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
 

poll.lua

@@ -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 .. ")"
@@ -305,7 +305,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

user_groups.lua

@@ -1,5 +1,6 @@
 global.regulars = {}
 local Event = require "utils.event"
+local Utils = require "utils.utils"
 
 local Module = {}
 
@@ -21,7 +22,7 @@ Module.is_regular = function(player_name)
 end
 
 Module.add_regular = function(player_name)
-    local actor = get_actor()
+    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
@@ -36,7 +37,7 @@ Module.add_regular = function(player_name)
 end
 
 Module.remove_regular = function(player_name)
-    local actor = get_actor()
+    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

utils/utils.lua

@@ -1,487 +1,20 @@
--- 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 Event = require "utils.event"
 
-colors = {
+local Module = {}
-	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 = {
+Module.distance = function(pos1, pos2)
-	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)
 	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
+Module.print_except = function(msg, player)
-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)
 	for _,p in pairs(game.players) do
 		if p.connected and p ~= player then
 			p.print(msg)
@@ -489,7 +22,7 @@ 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)
@@ -497,7 +30,7 @@ function print_admins(msg)
 	end
 end
 
-function get_actor()
+Module.get_actor = function()
 	if game.player then return game.player.name end
 	return "<server>"
 end